from datetime import datetime
from http.client import HTTPException
import os
from typing import Tuple
from fastapi import Path
from openai import OpenAI
import json
import pandas as pd
import requests
from pandasql import sqldf
import re
from loguru import logger

from app.datatk.data_help import DataHelp
from app.models.db import AnalysisReport


class AiPrompt:
    def __init__():
        pass
    
    @staticmethod
    def build_report_prompt(fxsm: str, fxsource: str) -> str:
        """构建分析报告提示词"""
        return f"""
            # 角色设定:你是一位资深[行业领域]的分析报告生成专家，擅长根据给定的分析说明和相关数据，生成长度适宜的分析报告。
            
            ### 技能 1: 生成分析报告
            1. 仔细研读用户提供的 "分析说明{fxsm}",结合数据源[{fxsource}]。
            2. 基于 "分析要基于用户发送给你的全部数据"，不得精简,需要深入剖析数据与分析说明之间的关联。
            3. 依据上述分析，生成一份逻辑清晰、重点突出且长度适宜的分析报告。
            4. 必须分析全部数据,不得缺少任何关键信息。
            5. 当用户发给你的数据长度超过了你得处理能力,必须用"您提供的数据超出了我的分析能力"来回复用户。
            6. 以'序号'列作为每一行的开头依次读取数据
            ### 限制:
            - 分析报告的生成必须严格基于用户提供的分析说明和数据。
            - 对于数据部分尽量采用表格形式。
            - 报告内容应紧扣分析主题，避免无关信息的添加,尽量避免列出数据明细
            - 数据概要中必须包括用户发送的数据行数和列数,分析来源字段等。 
            """

    @staticmethod
    def build_recxmsg_prompt(question: str, jsondata) -> str:
        """
        构建查询回复提示词
        
        @deprecated: 此方法已废弃，建议使用 build_smart_response_prompt() 方法，
        该方法能够自动判断用户意图并选择合适的回复风格。
        """
        return f"""
                # 角色设定
                你是一位简洁高效的数据分析师，目标是直观呈现用户查询结果，不进行深度分析，只提供基本汇总信息。

                # 输入信息
                1. **用户问题**："{question}"  
                2. **查询结果**：  
                {jsondata}

                # 生成规则 
                ## 核心原则
                - 简洁明了：用最简短的语言呈现查询结果
                - 直接回答：直接回应用户的具体问题
                - 无分析：只呈现数据，不做深度分析或推测
                - 客观呈现：不提供建议或行动方案

                ## 内容要求
                1. **数据概览**
                   - 简述查询返回的记录数量
                   - 说明数据的时间范围(如有)
                   - 最多提供3个关键数值的汇总(总计、平均值、最大值等)
                
                2. **简单格式化**
                   - 对数值使用千位分隔符(例如：1,234)
                   - 对日期使用友好格式(例如："2023年6月")
                   - 百分比保留1位小数(例如：12.5%)
                
                3. **数据为空处理**
                   - 清晰说明未找到匹配数据
                   - 简单建议检查查询条件

                ## 输出格式
                - 不使用复杂的标题和章节
                - 使用简单的自然语言
                - 避免使用SQL、数据库等技术术语
                - 避免使用表格和复杂格式

                ## 输出示例
                示例1：
                问题："销售额最高的3个产品是什么？"
                回复："查询结果显示，销售额最高的3个产品是手机(¥12,350)、笔记本电脑(¥9,840)和平板电脑(¥5,620)。"

                示例2：
                问题："上个月有多少新客户？"
                回复："2023年6月共有28位新客户注册，占当月总客户数的15.2%。"

                示例3：
                问题："哪个地区的退货率最高？"
                回复："共有5个地区的退货数据，其中华东地区退货率最高，为4.8%，北方地区最低，为1.2%。"

                示例4：
                问题："今年的销售额是多少？"
                回复："2023年至今的总销售额为¥1,458,320，比去年同期增加了¥125,680。"

                示例5：
                问题："查询符合条件的订单"
                回复："未找到符合条件的订单记录，请检查筛选条件是否过于严格。"
                """

    @staticmethod
    def build_refxmsg_prompt(question: str, jsondata) -> str:
        """
        构建分析回复提示词
        
        @deprecated: 此方法已废弃，建议使用 build_smart_response_prompt() 方法，
        该方法能够自动判断用户意图并选择合适的回复风格。
        """
        
        # 处理字符串格式的jsondata，转换为JSON数组并获取第一个元素的data属性
        try:
            if isinstance(jsondata, str):
                json_array = json.loads(jsondata)
                if isinstance(json_array, list) and len(json_array) > 0 and 'data' in json_array[0]:
                    jsondata = json_array[0]['data']
                    # 如果data还是字符串，则再次解析
                    if isinstance(jsondata, str):
                        try:
                            jsondata = json.loads(jsondata)
                        except:
                            pass
        except Exception as e:
            logger.error(f"处理JSON数据时出错: {str(e)}")
            # 发生错误时保持原始数据不变
            
        return f"""
             # 角色定位
             你是一位精确客观的数据分析师，擅长根据用户需求定制分析报告。你的分析既要洞察深入，又要遵循用户指定的各类限制条件。

             # 输入信息
             1. **用户问题**："{question}"  
             2. **查询结果数据**：  
             {jsondata}

             # 首要任务：分析用户限制条件
             在开始数据分析前，仔细分析用户问题中的限制条件：
             - 字数限制（如"分析不超过50字"、"简短回复"等）
             - 内容限制（如"只关注销售额"、"仅分析近30天数据"等）
             - 格式限制（如"以列表形式"、"需要表格"等）
             - 深度限制（如"简要概述"、"深入分析"等）
             
             按照用户指定的所有限制条件调整你的回复，这些限制条件的优先级高于下方的标准格式要求。

             # 标准分析结构（如用户未指定特殊格式）
             ## [核心结论]  
             - 用简明语言概括核心发现，包含关键指标的变化方向与幅度  
             - 如用户要求简短，此部分应包含最重要的1-2个发现

             ## [数据分析]  
             - 选择最相关的维度进行分析（如时间、地区、产品类别等）
             - 提供数据支持的具体证据（如"销售额从1月的1.2万增长到2月的1.5万"）
             - 解释数据背后的业务意义

             ## [建议行动]  
             - 如果用户需要建议，给出基于数据分析的具体可行建议
             - 说明建议与数据的关联性

             # 指导原则
             - 数据准确性：不曲解数据，如无显著差异需明确说明
             - 措辞客观：区分"相关"与"因果"，避免无依据的断言
             - 适应限制：灵活调整分析深度和格式以符合用户限制条件
             - 不确定性：当数据不足或分析有局限时，明确表明

             # 输出示例
             以下是根据不同限制条件的输出示例：

             1. 标准分析（无特殊限制）：  
             [核心结论] 6月会员复购率降至41%（比3月低17个百分点），与非会员差距缩小至9%，主要受价格折扣调整影响。

             [数据分析]
             1. **价格因素影响**：会员专享折扣从25%降至15%，接近通用促销力度，导致会员价格优势减弱。
             2. **渠道差异**：APP渠道会员复购率下降更明显（-28%），而小程序渠道降幅较小（-12%）。

             [建议行动]
             1. 恢复会员专享折扣力度，确保与非会员价差≥15%
             2. 在小程序订单流程中增强会员身份识别和专属权益展示

             2. 简短分析（字数限制50字）：  
             6月会员复购率41%，环比降17%。主因：会员折扣减少，价格优势缩小。建议：提高会员专享折扣力度。

             3. 重点关注特定方面（内容限制）：  
             [渠道分析] 复购率下降在各渠道表现不同：APP降幅28%，小程序降幅12%，线下门店基本持平。建议在APP端优先恢复会员权益，并加强与小程序的会员体系打通。
                """

    @staticmethod
    def build_smart_response_prompt(question: str, task_data_list) -> str:
        """
        智能构建回复提示词，根据用户问题自动判断是数据获取还是数据分析需求
        支持任务状态感知，能够处理成功、失败、错误等不同状态的任务
        
        参数:
            question (str): 用户问题
            task_data_list: JSON数组，格式为 [{"data": 数据, "datadec": 数据说明, "task_name": 任务名称, "status": 任务状态, "error_message": 错误信息}]
            
        返回:
            str: 适合的提示词
        """
        
        # 解析任务数据
        try:
            if isinstance(task_data_list, str):
                task_data_list = json.loads(task_data_list)
            if not isinstance(task_data_list, list):
                task_data_list = []
        except Exception as e:
            logger.error(f"解析任务数据时出错: {str(e)}")
            task_data_list = []
        
        # 统计数据量和分析任务状态
        total_data_count = 0
        has_data = False
        data_summary = []
        
        # 任务状态统计
        task_status_stats = {
            'completed': 0,
            'failed': 0,
            'error': 0,
            'pending': 0,
            'other': 0
        }
        
        failed_tasks = []
        error_tasks = []
        successful_tasks = []
        
        for task in task_data_list:
            if isinstance(task, dict):
                task_name = task.get('task_name', '未知任务')
                task_type = task.get('task_type', '数据查询')
                status = task.get('status', 'unknown')
                data = task.get('data', [])
                datadec = task.get('datadec', '')
                error_message = task.get('error_message', '')
                message = task.get('message', '')
                
                # 统计任务状态
                if status in task_status_stats:
                    task_status_stats[status] += 1
                else:
                    task_status_stats['other'] += 1
                
                # 分类收集任务信息
                if status == 'failed':
                    failed_tasks.append({
                        'name': task_name,
                        'type': task_type,
                        'description': datadec,
                        'error': error_message,
                        'message': message
                    })
                elif status == 'error':
                    error_tasks.append({
                        'name': task_name,
                        'type': task_type,
                        'description': datadec,
                        'error': error_message,
                        'message': message
                    })
                elif status == 'completed':
                    # 统计成功任务的数据量
                    if data:
                        if isinstance(data, list):
                            data_count = len(data)
                        else:
                            data_count = 1
                        total_data_count += data_count
                        has_data = True
                        
                        successful_tasks.append({
                            'name': task_name,
                            'type': task_type,
                            'description': datadec,
                            'data_count': data_count,
                            'message': message
                        })
                    else:
                        successful_tasks.append({
                            'name': task_name,
                            'type': task_type,
                            'description': datadec,
                            'data_count': 0,
                            'message': message
                        })
        
        # 确定整体任务执行状况
        total_tasks = len(task_data_list)
        failed_count = task_status_stats['failed']
        error_count = task_status_stats['error']
        completed_count = task_status_stats['completed']
        
        # 确定主要处理策略
        if total_tasks == 0:
            execution_status = "no_tasks"
            strategy_description = "没有相关任务"
        elif failed_count > 0 or error_count > 0:
            if completed_count == 0:
                execution_status = "all_failed"
                strategy_description = f"所有任务执行失败（失败:{failed_count}个，错误:{error_count}个）"
            else:
                execution_status = "partial_failed"
                strategy_description = f"部分任务失败（成功:{completed_count}个，失败:{failed_count}个，错误:{error_count}个）"
        elif completed_count > 0:
            if total_data_count == 0:
                execution_status = "completed_no_data"
                strategy_description = f"任务执行成功但无数据返回（{completed_count}个任务）"
            elif total_data_count <= 100:
                execution_status = "completed_small_data"
                strategy_description = f"任务执行成功，数据量适中（{completed_count}个任务，{total_data_count}条数据）"
            else:
                execution_status = "completed_large_data"
                strategy_description = f"任务执行成功，数据量较大（{completed_count}个任务，{total_data_count}条数据）"
        else:
            execution_status = "unknown"
            strategy_description = "任务状态未知"
        
        # 构建任务执行概览
        task_overview = f"""
## 📊 任务执行概览
**总任务数**: {total_tasks}个
**执行状况**: {strategy_description}
**状态分布**: 成功{completed_count}个，失败{failed_count}个，错误{error_count}个
"""
        
        # 构建失败任务详情
        failure_details = ""
        if failed_tasks or error_tasks:
            failure_details = "\n## ❌ 失败任务详情\n"
            
            if failed_tasks:
                failure_details += "**执行失败的任务**:\n"
                for i, task in enumerate(failed_tasks, 1):
                    failure_details += f"{i}. **{task['name']}** ({task['type']})\n"
                    failure_details += f"   - 任务描述: {task['description']}\n"
                    failure_details += f"   - 失败原因: {task['error']}\n"
                    failure_details += f"   - 状态信息: {task['message']}\n\n"
            
            if error_tasks:
                failure_details += "**数据错误的任务**:\n"
                for i, task in enumerate(error_tasks, 1):
                    failure_details += f"{i}. **{task['name']}** ({task['type']})\n"
                    failure_details += f"   - 任务描述: {task['description']}\n"
                    failure_details += f"   - 错误信息: {task['error']}\n"
                    failure_details += f"   - 状态信息: {task['message']}\n\n"
        
        # 构建成功任务概览和实际数据内容
        success_overview = ""
        actual_data_content = ""
        if successful_tasks:
            success_overview = "\n## ✅ 成功任务概览\n"
            actual_data_content = "\n## 📊 实际查询数据内容\n"
            
            for i, task in enumerate(successful_tasks, 1):
                success_overview += f"{i}. **{task['name']}** ({task['type']}) - {task['data_count']}条数据\n"
                if task['description']:
                    success_overview += f"   - 说明: {task['description']}\n"
            
            # 添加实际数据内容
            actual_data_content += "**重要：以下是实际查询得到的数据，必须基于这些真实数据进行回复，不能编造或猜测！**\n\n"
            
            for task in task_data_list:
                if isinstance(task, dict) and task.get('status') == 'completed':
                    task_name = task.get('task_name', '未知任务')
                    data = task.get('data', [])
                    datadec = task.get('datadec', '')
                    
                    if data:
                        actual_data_content += f"### 📋 {task_name} 数据\n"
                        if datadec:
                            actual_data_content += f"**数据说明**: {datadec}\n"
                        
                        # 将数据转换为字符串格式
                        if isinstance(data, list):
                            actual_data_content += f"**数据内容** ({len(data)}条记录):\n"
                            actual_data_content += "```json\n"
                            actual_data_content += json.dumps(data, ensure_ascii=False, indent=2)
                            actual_data_content += "\n```\n\n"
                        else:
                            actual_data_content += f"**数据内容**:\n"
                            actual_data_content += "```json\n"
                            actual_data_content += json.dumps(data, ensure_ascii=False, indent=2)
                            actual_data_content += "\n```\n\n"
                    else:
                        actual_data_content += f"### 📋 {task_name} 数据\n"
                        actual_data_content += f"**数据说明**: {datadec}\n"
                        actual_data_content += "**数据内容**: 查询成功但未返回数据\n\n"
        
        # 根据执行状况确定回复策略
        if execution_status == "no_tasks":
            strategy_guidance = """
### 🚫 无任务处理策略
- **回复重点**: 说明没有找到相关的数据查询任务
- **分析方向**: 
  1. 解释可能的原因（任务未执行、查询条件等）
  2. 建议用户重新提交查询或检查任务状态
  3. 提供获取数据的替代方案
- **回复风格**: 友好提示，引导用户正确操作
"""
        elif execution_status == "all_failed":
            strategy_guidance = """
### ❌ 全部失败处理策略
- **回复重点**: 简洁客观地说明任务失败情况
- **分析方向**:
  1. **失败陈述**: 简要描述任务失败的事实
  2. **状态汇总**: 仅提供失败任务的基本信息
  3. **避免分析**: 不深入分析失败原因
  4. **不提建议**: 不提供解决方案或修复建议
- **回复风格**: 简洁客观，只陈述事实
- **重要**: 不分析技术问题，不提供技术建议
"""
        elif execution_status == "partial_failed":
            strategy_guidance = """
### ⚠️ 部分失败处理策略
- **回复重点**: 优先展示成功数据结果，简洁说明失败情况
- **分析方向**:
  1. **成功结果优先**: 主要分析成功获取的数据
  2. **失败简述**: 简要提及哪些任务失败，不详细分析原因
  3. **范围说明**: 客观说明分析基于哪部分数据
  4. **避免建议**: 不提供关于失败任务的建议
- **回复风格**: 积极正面，聚焦于可用数据的分析
- **数据处理**: 基于成功任务的数据进行分析，简单标注数据范围
"""
        elif execution_status == "completed_no_data":
            strategy_guidance = """
### 📭 成功但无数据处理策略
- **回复重点**: 简洁陈述查询成功但未返回数据的事实
- **分析方向**:
  1. **结果陈述**: 客观说明查询未返回任何数据
  2. **执行确认**: 确认查询已正确执行
  3. **避免猜测**: 不推测数据不存在的原因
  4. **不提建议**: 不提供修改查询的建议
- **回复风格**: 简洁客观，只陈述事实
"""
        elif execution_status == "completed_small_data":
            strategy_guidance = f"""
### 📋 成功小数据量处理策略 ({total_data_count}条)
- **回复重点**: 详细展示数据并进行精确分析
- **关键要求**: **必须严格基于上述实际查询数据进行回复，绝对不能编造、猜测或使用任何虚假信息！**
- **分析方向**:
  1. 提供精确的数值和具体的对比（基于真实数据）
  2. 可以逐项分析和细致的模式识别（引用实际数据内容）
  3. 进行详细的趋势分析和异常识别（使用查询到的真实数值）
  4. 基于完整数据提供精准建议（所有建议必须有实际数据支撑）
- **回复风格**: 详细准确，数据支撑充分
- **数据引用**: 可以引用具体数值和详细统计，但必须来自上述实际查询结果
- **严格禁止**: 不得编造任何数据、不得使用假设性信息、不得猜测未查询到的内容
"""
        else:  # completed_large_data
            strategy_guidance = f"""
### 📊 成功大数据量处理策略 ({total_data_count}条)
- **回复重点**: 重点关注汇总统计和宏观趋势
- **关键要求**: **必须严格基于上述实际查询数据进行回复，绝对不能编造、猜测或使用任何虚假信息！**
- **分析方向**:
  1. 使用统计指标（平均值、总计、百分比等）- 基于实际查询数据计算
  2. 识别主要模式和关键趋势 - 从真实数据中发现
  3. 提供分类汇总和对比分析 - 使用实际数据进行统计
  4. 避免过度细节，专注核心洞察 - 但洞察必须来自真实数据
- **回复风格**: 简洁有力，突出关键发现
- **数据引用**: 使用汇总数据和统计指标，但必须基于上述实际查询结果计算，避免列举具体条目
- **严格禁止**: 不得编造任何统计数据、不得使用假设性比例、不得猜测未包含在查询结果中的信息
"""
        
        return f"""
# 🤖 智能数据助手 - 任务状态感知系统

## 📋 输入分析
**用户问题**: "{question}"
**任务执行状况**: {execution_status} ({strategy_description})

{task_overview}

{failure_details}

{success_overview}

{actual_data_content}

{strategy_guidance}

## 🎯 核心任务与智能回复策略

### 第一步：用户意图识别（必须明确判断）

**🔍 数据获取型** - 用户想要事实和数字：
- 关键词：查询、显示、列出、多少、几个、什么、哪个、排名、总数、统计
- 特征：直接询问具体数值、排序、筛选结果
- 期望：快速、准确的数据呈现

**📊 数据分析型** - 用户需要洞察和建议：
- 关键词：分析、为什么、如何、趋势、原因、建议、对比、评估、影响
- 特征：寻求解释、建议、深层理解
- 期望：专业分析和可行建议

### 第二步：任务状态感知回复

#### ❌ 全部失败情况
**回复模板**:
```
很抱歉，数据查询任务执行遇到问题：

**失败任务说明**:
[简洁描述每个失败任务的错误情况]

**问题概述**:
[简明指出失败的主要原因，不提供具体解决方案]
```

#### ⚠️ 部分失败情况
**回复模板**:
```
基于部分成功的查询结果，我为您提供以下分析：

**[基于成功数据的核心回答]**

**数据完整性说明**:
- ✅ 成功获取: [成功任务列表]
- ❌ 执行失败: [失败任务情况简述]
- 📊 当前分析基于: [可用数据范围]
```

#### 📭 成功但无数据情况
**回复模板**:
```
查询执行成功，但未找到符合条件的数据。

**查询状况**:
[简要说明执行的查询任务]

**结果说明**:
[简洁陈述查询结果为空的事实，不分析原因]
```

#### ✅ 成功有数据情况
**数据获取型回复模板**:
```
小数据量(≤100条):
"[直接回答] + [具体数据展示] + [精确统计]"

大数据量(>100条):
"[汇总回答] + [关键统计指标] + [重要排名]"
```

**数据分析型回复模板**:
```
小数据量:
**核心发现**: [基于完整数据的精确洞察]
**数据支撑**: [具体数值和详细统计]
**深度分析**: [逐项分析和模式识别]
**建议**: [基于完整数据的精准建议]

大数据量:
**宏观洞察**: [基于大数据的整体趋势]
**统计支撑**: [汇总指标和百分比]
**关键发现**: [最重要的3-5个发现]
**策略建议**: [基于统计分析的高层建议]
```

## 🔧 特殊场景处理指南

### 失败任务处理原则
1. **客观陈述**: 只描述失败事实，不分析技术原因
2. **简明扼要**: 简洁说明失败情况，不详细展开
3. **避免诊断**: 不提供技术层面的诊断分析
4. **不提建议**: 不提供任何解决方案或修复建议

### 数据完整性处理
1. **明确标注数据来源**: 说明分析基于哪些成功的任务
2. **注明范围**: 简单说明使用的数据范围
3. **完整性标注**: 客观提及部分数据缺失的事实
4. **中立陈述**: 不对数据缺失做价值判断

### 用户体验优化
1. **积极正面**: 优先展示能够提供的价值
2. **简洁清晰**: 保持回复简明扼要
3. **专注事实**: 只关注数据事实，避免猜测
4. **专业可信**: 保持专业、客观的语调

## 📋 质量检查清单
生成回复前，请确认：
1. ✅ 是否准确识别了用户意图类型
2. ✅ 是否正确处理了所有任务状态
3. ✅ 失败任务是否得到合理解释
4. ✅ 成功数据是否得到充分利用
5. ✅ 是否提供了可操作的建议
6. ✅ 回复是否积极正面且专业可信
7. ✅ 数据引用是否准确且适合数据量级

## 🎯 执行指令
现在，请基于上述任务状态感知框架，为用户生成最优质的智能回复：

1. **状态分析**: 全面分析所有任务的执行状况
2. **意图识别**: 明确判断用户问题类型和期望
3. **策略选择**: 根据任务状态选择最合适的回复策略
4. **内容生成**: 平衡处理成功数据和失败问题
5. **质量保证**: 确保回复的准确性、专业性和可操作性

**重要原则**:
- 优先展示有价值的信息和分析
- 诚实透明地处理失败和问题
- 提供具体可操作的解决方案
- 保持专业、积极、有帮助的语调

**开始生成任务状态感知的智能回复** ⬇️
"""

    @staticmethod
    def build_advanced_smart_response_prompt(question: str, all_task_data, context: dict = None) -> str:
        """
        高级智能回复提示词，支持上下文感知和个性化
        
        参数:
            question (str): 用户问题
            all_task_data: JSON数组，格式为 [{"data": 数据, "datadec": 数据说明, "task_name": 任务名称}]
            context (dict, optional): 上下文信息，包含：
                - user_preference: 用户偏好（简洁/详细）
                - conversation_history: 对话历史
                - domain_context: 业务领域上下文
                - urgency_level: 紧急程度
                
        返回:
            str: 高级智能提示词
        """
        
        # 解析任务数据
        try:
            if isinstance(all_task_data, str):
                task_data_list = json.loads(all_task_data)
            else:
                task_data_list = all_task_data
                
            if not isinstance(task_data_list, list):
                task_data_list = []
        except Exception as e:
            logger.error(f"解析任务数据时出错: {str(e)}")
            task_data_list = []
        
        # 统计数据量和分析数据特征
        total_data_count = 0
        has_data = False
        data_summary = []
        data_complexity = "unknown"
        
        for task in task_data_list:
            if isinstance(task, dict):
                task_name = task.get('task_name', '未知任务')
                data = task.get('data', [])
                datadec = task.get('datadec', '')
                
                # 统计数据量
                if data:
                    if isinstance(data, list):
                        data_count = len(data)
                    else:
                        data_count = 1
                    total_data_count += data_count
                    has_data = True
                    
                    data_summary.append({
                        'task_name': task_name,
                        'data_count': data_count,
                        'description': datadec,
                        'data_type': 'list' if isinstance(data, list) else 'object'
                    })
                else:
                    data_summary.append({
                        'task_name': task_name,
                        'data_count': 0,
                        'description': datadec,
                        'data_type': 'empty'
                    })
        
        # 分析数据复杂度
        if total_data_count == 0:
            data_complexity = "empty"
        elif total_data_count == 1:
            data_complexity = "simple_value"
        elif total_data_count <= 10:
            data_complexity = "small_dataset"
        elif total_data_count <= 100:
            data_complexity = "medium_dataset"
        else:
            data_complexity = "large_dataset"
        
        # 根据数据量确定处理策略
        if total_data_count == 0:
            data_strategy = "empty"
            strategy_description = "所有任务都没有返回数据"
        elif total_data_count <= 100:
            data_strategy = "detailed"
            strategy_description = f"中小数据量({total_data_count}条)，支持详细分析"
        else:
            data_strategy = "summary"
            strategy_description = f"大数据量({total_data_count}条)，需要汇总分析"
        
        # 处理上下文信息
        context = context or {}
        user_preference = context.get('user_preference', 'balanced')  # simple/detailed/balanced
        conversation_history = context.get('conversation_history', [])
        domain_context = context.get('domain_context', 'general')
        urgency_level = context.get('urgency_level', 'normal')  # low/normal/high
        
        # 构建数据概览和实际数据内容
        data_overview = ""
        actual_data_content = ""
        
        if has_data:
            data_overview = f"""
## 📊 任务数据概览
**总数据量**: {total_data_count}条记录
**数据复杂度**: {data_complexity}
**处理策略**: {strategy_description}

### 各任务数据情况
"""
            for summary in data_summary:
                data_overview += f"- **{summary['task_name']}**: {summary['data_count']}条数据 ({summary['data_type']}) - {summary['description']}\n"
            
            # 构建实际数据内容部分
            actual_data_content = f"""
## 🎯 实际查询数据内容
**⚠️ 关键要求：以下是实际查询得到的真实数据，必须严格基于这些数据进行回复，绝对不能编造、猜测或使用任何虚假信息！**

### 📋 完整数据内容
"""
            for task in task_data_list:
                if isinstance(task, dict):
                    task_name = task.get('task_name', '未知任务')
                    data = task.get('data', [])
                    datadec = task.get('datadec', '')
                    task_type = task.get('task_type', '数据查询')
                    
                    if data:
                        actual_data_content += f"""
#### 📊 {task_name} ({task_type})
**数据说明**: {datadec}
**数据条数**: {len(data) if isinstance(data, list) else 1}条
**数据内容**:
```json
{json.dumps(data, ensure_ascii=False, indent=2)}
```
"""
                    else:
                        actual_data_content += f"""
#### 📊 {task_name} ({task_type})
**数据说明**: {datadec}
**数据状态**: 查询成功但未返回数据
"""
        else:
            data_overview = """
## 🚫 数据状态
**状态**: 所有任务都没有返回有效数据
**可能原因**: 查询条件过于严格、数据源为空、或查询语句有误

### 任务执行情况
"""
            for summary in data_summary:
                data_overview += f"- **{summary['task_name']}**: 无数据 - {summary['description']}\n"
            
            actual_data_content = """
## 🚫 数据状态说明
**重要提醒**: 由于所有任务都没有返回数据，请基于实际情况回复，不要编造任何数据或信息。
"""
        
        # 分析会话历史中的偏好
        historical_context = ""
        if conversation_history:
            chart_mentions = 0
            report_mentions = 0
            analysis_depth = 0
            
            for msg in conversation_history[-5:]:
                if isinstance(msg, dict):
                    content = msg.get('content', '').lower()
                    if any(word in content for word in ['图表', '图', 'chart', '可视化']):
                        chart_mentions += 1
                    if any(word in content for word in ['报告', 'report', '总结']):
                        report_mentions += 1
                    if any(word in content for word in ['分析', '深入', '详细', '原因']):
                        analysis_depth += 1
            
            historical_context = f"""
### 📈 历史对话分析
- **可视化偏好**: {chart_mentions}/5 {"(偏好图表展示)" if chart_mentions >= 2 else ""}
- **报告偏好**: {report_mentions}/5 {"(偏好报告总结)" if report_mentions >= 2 else ""}
- **分析深度**: {analysis_depth}/5 {"(偏好深度分析)" if analysis_depth >= 3 else "(偏好简洁回复)" if analysis_depth <= 1 else ""}
"""
        
        # 根据数据策略和上下文构建回复指导
        if data_strategy == "empty":
            strategy_guidance = f"""
### 🚫 空数据处理策略
**上下文适配**:
- **用户偏好({user_preference})**: {"提供简洁的问题诊断" if user_preference == "simple" else "详细分析可能原因" if user_preference == "detailed" else "平衡的问题分析和建议"}
- **紧急程度({urgency_level})**: {"立即提供关键解决方案" if urgency_level == "high" else "提供完整的问题诊断和多种解决方案" if urgency_level == "low" else "提供主要原因和核心建议"}
- **业务领域({domain_context})**: 结合{domain_context}领域的常见数据问题

**回复策略**:
1. 友好说明数据为空的情况
2. 基于业务领域分析可能原因
3. 提供针对性的解决建议
4. 根据紧急程度调整回复详细度
"""
        elif data_strategy == "detailed":
            strategy_guidance = f"""
### 📋 详细分析策略 ({total_data_count}条数据)
**🚨 数据使用要求**: **必须严格基于上述实际查询数据进行回复，绝对不能编造、猜测或使用任何虚假信息！**

**上下文适配**:
- **用户偏好({user_preference})**: {"突出关键数字和结论" if user_preference == "simple" else "提供完整的数据分析和深度洞察" if user_preference == "detailed" else "平衡数据展示和分析洞察"}
- **紧急程度({urgency_level})**: {"优先提供核心答案和关键行动点" if urgency_level == "high" else "可以提供详细的数据分析和背景信息" if urgency_level == "low" else "标准的结构化分析"}
- **业务领域({domain_context})**: 使用{domain_context}领域的专业术语和分析框架
- **数据复杂度({data_complexity})**: {"直接展示数值和业务含义" if data_complexity == "simple_value" else "完整展示数据并进行逐项分析" if data_complexity == "small_dataset" else "分类展示并突出关键发现"}

**回复策略**:
1. 可以引用具体数值和详细信息（但必须来自实际查询数据）
2. 提供精确的统计和对比分析（基于真实数据计算）
3. 进行逐项分析和模式识别（引用实际数据内容）
4. 根据业务领域提供专业建议（建议必须有实际数据支撑）

**严格禁止**:
- ❌ 不得编造任何数据或数值
- ❌ 不得使用假设性信息或推测
- ❌ 不得猜测未查询到的内容
- ❌ 不得使用虚构的案例或示例数据
"""
        else:  # summary
            strategy_guidance = f"""
### 📊 汇总分析策略 ({total_data_count}条数据)
**🚨 数据使用要求**: **必须严格基于上述实际查询数据进行回复，绝对不能编造、猜测或使用任何虚假信息！**

**上下文适配**:
- **用户偏好({user_preference})**: {"提供核心统计指标和关键结论" if user_preference == "simple" else "详细的统计分析和深度洞察" if user_preference == "detailed" else "平衡的汇总分析和重点发现"}
- **紧急程度({urgency_level})**: {"立即提供关键统计和核心洞察" if urgency_level == "high" else "可以提供详细的统计分析和趋势解读" if urgency_level == "low" else "标准的汇总分析"}
- **业务领域({domain_context})**: 关注{domain_context}领域的关键指标和业务逻辑
- **数据复杂度(large_dataset)**: 重点关注汇总统计和宏观趋势

**回复策略**:
1. 使用统计指标和汇总信息（但必须基于实际查询数据计算）
2. 识别主要模式和关键趋势（从真实数据中发现）
3. 避免过度细节，专注核心洞察（但洞察必须来自真实数据）
4. 提供基于统计分析的策略建议（建议必须有实际数据支撑）

**严格禁止**:
- ❌ 不得编造任何统计数据或指标
- ❌ 不得使用假设性比例或百分比
- ❌ 不得猜测未包含在查询结果中的信息
- ❌ 不得创造虚假的趋势或模式
"""
        
        return f"""
# 🧠 高级智能数据助手 - 上下文感知系统

## 📊 输入分析
**用户问题**: "{question}"
**数据处理策略**: {data_strategy} ({strategy_description})
**用户偏好**: {user_preference}模式
**业务领域**: {domain_context}
**紧急程度**: {urgency_level}

{data_overview}

{actual_data_content}

{historical_context}

{strategy_guidance}

## 🎯 智能意图识别与上下文适配

### 第一层：语义分析
分析问题的语义结构，识别：
- **动作词**：查询/分析/比较/预测/建议
- **目标词**：数据/趋势/原因/方案/结果
- **修饰词**：快速/详细/简单/深入/紧急

### 第二层：意图分类与个性化

**🔍 信息获取型**（优先快速响应）:
- 特征：直接询问、具体数值、排序筛选
- 关键词：多少、什么、哪个、排名、总计、显示
- 个性化适配：
  * simple模式：一句话回答 + 关键数字
  * balanced模式：结构化数据 + 简要解释
  * detailed模式：完整数据 + 详细统计

**📈 洞察分析型**（深度解读）:
- 特征：寻求理解、要求建议、探索关系
- 关键词：为什么、如何、分析、趋势、影响、建议
- 个性化适配：
  * simple模式：核心洞察 + 关键建议
  * balanced模式：结构化分析 + 可行建议
  * detailed模式：深度分析 + 完整建议框架

## 🎨 多维度个性化适配

### 用户偏好适配
**{user_preference}模式特征**:
- **simple**: 一句话回答，突出关键数字和结论
- **balanced**: 结构化回复，数据展示+简要分析+核心建议
- **detailed**: 完整分析框架，深度洞察+详细建议+背景信息

### 紧急程度适配
**{urgency_level}紧急度策略**:
- **high**: 直接给出核心答案和关键行动点，省略背景信息
- **normal**: 标准结构化回复，平衡信息完整性和简洁性
- **low**: 可以提供更多背景、详细分析和多种方案

### 业务领域适配
**{domain_context}领域专业化**:
- 使用该领域的专业术语和分析框架
- 关注该领域的关键指标和业务逻辑
- 提供符合该领域实践的建议
- 考虑该领域的常见问题和解决方案

## 🚀 智能回复生成框架

### 数据量感知回复策略

#### 🚫 空数据情况 (0条)
**回复模板**（根据用户偏好调整）:
```
根据用户偏好选择回复模板：
- simple模式：数据为空，建议[核心解决方案]
- balanced模式：很抱歉没有找到数据。可能原因：[2-3个]。建议：[2-3个解决方案]
- detailed模式：[完整的问题分析] + [详细原因分析] + [多种解决方案] + [预防措施]
```

#### 📋 详细分析情况 (≤100条)
**信息获取型回复**:
```
根据用户偏好和紧急程度适配回复风格

示例(balanced+normal)：
"基于数据记录分析，[直接回答]。
关键发现：[2-3个要点]
详细数据：[根据需要展示具体数值]"
```

**洞察分析型回复**:
```
**核心洞察**: [基于完整数据的精确发现]
**数据证据**: [具体数值和详细统计]
**领域专业分析**: [专业角度的深度解读]
**可行建议**: [2-3个具体可执行的建议]
```

#### 📊 汇总分析情况 (>100条)
**信息获取型回复**:
```
"基于大量记录的汇总分析：
[关键统计指标] + [重要排名/对比] + [核心结论]"
```

**洞察分析型回复**:
```
**宏观洞察**: [基于大数据的整体趋势]
**统计支撑**: [汇总指标和百分比]
**领域专业视角**: [领域专业分析]
**策略建议**: [基于统计分析的高层建议]
```

## 🔧 质量保证与优化

### 必检项目
- ✅ 回答是否直接对应用户问题
- ✅ 是否符合用户偏好的详细程度
- ✅ 紧急程度是否得到适当响应
- ✅ 业务领域专业性是否体现
- ✅ **数据引用是否100%来自实际查询结果**
- ✅ **是否完全避免了编造、猜测和虚假信息**
- ✅ 数据使用是否适合数据量级
- ✅ 建议是否具有可操作性

### 上下文一致性
- 保持与历史对话的风格一致性
- 考虑用户的历史偏好和习惯
- 适应用户的专业水平和背景
- 确保术语使用的一致性

### 个性化优化
1. **准确性第一**: 根据数据量级调整精确度
2. **相关性优先**: 聚焦用户真正关心的问题
3. **适应性强**: 根据上下文调整回复风格
4. **可操作性**: 建议必须具体可执行
5. **专业性**: 体现业务领域的专业水准

## 📋 执行指令

请基于以上多维度框架，为用户生成最优质的个性化回复：

1. **意图识别**: 明确判断问题类型和用户期望
2. **上下文适配**: 全面考虑用户偏好、紧急程度、业务领域
3. **数据感知**: 根据数据量级选择最合适的回复策略
4. **个性化生成**: 选择最匹配的回复模板和风格
5. **质量检查**: 确保回复质量、准确性和一致性

**重要提醒**:
- 严格按照用户偏好调整回复详细程度
- 根据紧急程度优化信息优先级
- 体现业务领域的专业性和针对性
- **🚨 确保数据引用100%来自实际查询结果，绝对禁止编造任何信息**
- **⚠️ 所有统计、分析和建议都必须基于上述真实数据**

**开始生成高级个性化智能回复** ⬇️
"""

    @staticmethod
    def build_dimension_analysis_prompt(table_info: str, existing_dimensions=None, user_input: str = "") -> str:
        """
        构建系统推荐数据维度分析提示词，用于自动生成适当数量的维度分析方向
        
        参数:
            table_info (str): 表结构信息的JSON字符串
            existing_dimensions (list): 已有的分析维度列表
            user_input (str): 用户输入的分析需求,可选
            
        返回:
            str: 用于生成维度分析的提示词
        """
        # 解析表结构JSON字符串
        try:
            tablename=table_info.get("表名", "")
            # 获取列信息
            column_names = table_info.get("列信息", [])
            
            # 使用表结构中的列类型分类（如果存在）
            column_types = table_info.get("列类型分类", {}) 
            numeric_cols = column_types.get("数值型列", [])
            date_cols = column_types.get("日期型列", [])
            text_cols = column_types.get("文本型列", [])
            # 尝试识别分类列（通常是文本列中的低基数列）
            category_cols = column_types.get("分类型列", []) 
            # 获取表描述和SQL提示（如果存在）
            table_description = table_info.get("数据描述", "") 
            
        except (json.JSONDecodeError, Exception) as e:
            # 如果解析失败，使用默认值
            logger.error(f"解析表结构JSON失败: {str(e)}")
            column_names = []
            numeric_cols = []
            date_cols = []
            category_cols = []
            table_description = f"表 {tablename}"
        
        # 当前时间
        current_time = datetime.now().strftime("%Y-%m-%d")
        
        # 提取已有的分析维度和类别
        existing_dimensions_text = ""
        existing_categories = {}
        
        if existing_dimensions and len(existing_dimensions) > 0:
            dimensions_list = []
            for dim in existing_dimensions:
                if isinstance(dim, dict):
                    dim_name = dim.get("分析维度", dim.get("dimension_name", ""))
                    dim_desc = dim.get("分析描述", dim.get("dimension_description", ""))
                    dim_category = dim.get("分析类别", "")
                    
                    # 记录已有的维度
                    dimensions_list.append(f"- {dim_name}: {dim_desc} [类别: {dim_category}]")
                    
                    # 按类别统计已有维度
                    if dim_category:
                        if dim_category not in existing_categories:
                            existing_categories[dim_category] = []
                        existing_categories[dim_category].append(dim_name)
                
                elif isinstance(dim, str):
                    dimensions_list.append(f"- {dim}")
            
            if dimensions_list:
                existing_dimensions_text = "\n\n# 已有的分析维度（需要避免生成类似的维度）\n" + "\n".join(dimensions_list)
        
        # 格式化已有的分析类别及其维度数量
        existing_categories_text = ""
        if existing_categories:
            categories_list = []
            for category, dimensions in existing_categories.items():
                categories_list.append(f"- {category}: 已有{len(dimensions)}个维度 ({', '.join(dimensions)})")
            
            existing_categories_text = "\n\n# 已有的分析类别（优先考虑使用这些类别）\n" + "\n".join(categories_list)
        
        return f"""
        # 角色定位
        你是一位资深数据分析专家，擅长根据表结构识别有价值的分析维度并将其组织成有逻辑的报告章节。

        # 表结构信息
        - 表名: {tablename}
        - 表描述: {table_description}
        - 所有列: {column_names}
        - 可能的数值列: {numeric_cols}
        - 可能的日期列: {date_cols}
        - 可能的分类列: {category_cols}
        - 当前日期: {current_time}{existing_dimensions_text}{existing_categories_text}

        # 用户需求
        用户输入的分析需求: {user_input if user_input else "未指定具体需求"}

        # 任务结构
        依据以下优先级生成分析维度:
        1. 首要任务：优先考虑已有的分析类别，为每个类别补充分析维度，直到每个类别包含3-5个维度
        2. 次要任务：只有当现有的所有类别都已包含至少3个维度后，才考虑创建新的分析类别
        3. 类别限制：每次生成的新分析类别不超过3个，总的分析类别数量不超过6个

        # 类别与维度生成原则
        - 每个分析类别应包含3-5个相关联的分析维度，形成完整的分析视角
        - 同一类别下的分析维度应具有内在联系，共同解决某一方面的业务问题
        - 每次生成时的分析类别不超过3个，已有类别加新类别的总数不超过6个
        - 新增的分析维度必须与表中实际存在的列相关，确保可基于现有数据进行分析
        - 避免生成与已有分析维度类似或重复的维度

        # 现有类别维度补充示例
        假设已有"销售表现分析"类别，下面有2个分析维度:
        - "月度销售趋势"
        - "产品销售占比"
        
        你应优先为该类别再补充1-3个维度，例如:
        - "销售区域分布分析"
        - "销售渠道效率对比"
        - "促销活动销售影响"

        # 新类别创建示例
        只有当所有现有类别都已有足够维度后，且总类别数少于6个时，才创建新类别(每次最多创建3个新类别)，例如:
        - 新类别："客户行为分析"
          - "客户购买频次分布"
          - "客户购买金额层级"
          - "新老客户对比分析"
          - "客户产品偏好分析"

        # 重要说明
        1. 每次生成的分析类别不超过3个，已有类别加新类别的总数不超过6个
        2. 每个类别应包含3-5个分析维度，形成完整的分析视角
        3. 仅当所有现有类别都已达到至少3个维度后，才考虑创建新类别
        4. 分析维度必须与表中数据相关，确保可基于现有数据进行分析
        5. 分析描述必须详细且明确，以便后续能够根据描述生成相应的SQL查询
        6. 避免生成与已有分析维度类似或重复的维度
        7. 注重业务价值，确保每个分析维度都能解决实际业务问题
        
        # 输出格式
        请将分析结果以JSON数组格式输出，每个元素表示一个分析维度，必须包含以下三个字段：
        ```json
        [
          {{
            "分析维度": "销售额趋势分析",
            "分析描述": "按月/季/年分析销售额变化趋势，识别增长或下滑周期，评估业务发展状况与速度",
            "分析类别": "销售表现分析"
          }},
          {{
            "分析维度": "产品销售构成分析",
            "分析描述": "分析各产品类别销售额占比，找出核心产品和增长最快的产品类别，优化产品结构",
            "分析类别": "销售表现分析"
          }}
        ]
        ```
        """

    @staticmethod
    def build_echarts_config_prompt(sql: str, chart_type: str, user_request: str, datajson: str = None) -> str:
        """构建生成Echarts配置的提示词
        
        参数:
            sql (str): 统计SQL语句，可能包含多维度统计
            chart_type (str): 推荐图表类型，如"饼图"、"柱状图"等
            user_request (str): 用户输入的相关要求
            datajson (str, optional): SQL执行后的实际数据，JSON格式，允许模型直接使用数据生成配置
            
        返回:
            str: 用于生成Echarts配置的提示词
        """
        # 创建配置示例字符串，避免在f-string中嵌套过深的表达式
        config_example = '''{
            "title": { 
              "text": "图表标题",
              "subtext": "副标题或数据来源说明"
            },
            "tooltip": {
              "trigger": "axis",
              "formatter": "{b}: {c}"
            },
            "legend": {
              "type": "scroll",
              "data": ["系列1", "系列2"]
            },
            "grid": {
              "left": "3%",
              "right": "4%",
              "bottom": "3%",
              "containLabel": true
            },
            "xAxis": {
              "type": "category",
              "data": ["类别1", "类别2"]
            },
            "yAxis": {
              "type": "value",
              "axisLabel": {
                "formatter": "{value} 单位"
              }
            },
            "series": [
              {
                "name": "系列1",
                "type": "bar",
                "data": [120, 200]
              }
            ],
            "color": ["#5470c6", "#91cc75", "#fac858", "#ee6666"],
            "dataZoom": [{
              "type": "inside",
              "start": 0,
              "end": 100
            }]
          }'''
          
        # 准备数据部分的提示
        data_instruction = ""
        if datajson:
            data_instruction = f"""
            ## 实际数据 (直接用于图表)
            以下是SQL查询的实际执行结果，你应直接使用这些数据构建Echarts配置：
            ```json
            {datajson}
            ```
            
            注意事项:
            1. 将上方提供的实际数据直接用于Echarts配置中的数据部分
            2. 不要假设数据列的名称或结构，请严格使用提供的数据格式
            3. 确保提取正确的维度和指标字段，维度通常是类别型数据，指标通常是数值型数据
            4. 如果数据中包含时间格式，根据需要进行格式化处理
            5. 对于多维数据，正确设置系列(series)和图例(legend)
            """
              
        return f"""
        # 角色设定：你是一位专业的数据可视化专家，精通Echarts 4.X版本的配置和各类数据分析可视化

        ## 任务
        根据提供的SQL语句、数据表信息和用户需求，生成适合的Echarts 4.X版本配置项JSON，用于前端直接渲染图表。

        ## 输入数据分析
        1. SQL语句（可能包含多维度统计）: ```{sql}```
        2. 推荐图表类型: {chart_type}
        3. 用户需求: {user_request}
        {data_instruction}

        ## SQL分析步骤
        1. 解析SQL结构，识别SELECT字段列表、FROM子句、WHERE条件、GROUP BY分组、ORDER BY排序等
        2. 识别维度字段：通常是GROUP BY后的字段，或SELECT中非聚合函数字段
        3. 识别指标字段：通常是带聚合函数(SUM, AVG, COUNT等)的字段
        4. 分析WHERE条件，了解数据筛选范围
        5. 分析ORDER BY，确定数据的排序逻辑
        6. 检测是否包含HAVING子句，了解聚合后的过滤条件
        7. 检测是否包含子查询或UNION等复杂结构
        8. 判断是单维度分析还是多维度分析
        9. 识别时间相关字段，确定是否为时间序列分析

        ## ⚠️ 重要约束 ⚠️
        1. 必须使用Echarts 4.X版本的配置语法
        2. 所有配置必须是纯JSON格式，可以被JSON.parse()直接解析
        3. 对于需要使用函数的情况（如formatter），请使用字符串模板代替：
           - 错误示例：`"formatter": (d) => \`${{d.产品}} (${{d.比例}}%) \``
           - 正确示例：`"formatter": "{{产品}} ({{比例}}%)"`
        4. 避免使用以下非JSON标准的内容：
           - JavaScript函数
           - undefined值
           - 未闭合的引号或括号
           - 注释
           - 尾随逗号
        5. 数据管理要求：
           - 所有数据必须通过dataset统一管理
           - 使用dataset.source配置数据源
           - 通过encode配置数据映射关系
           - 避免在series中直接配置data

        ## 图表类型选择指南
        ### 饼图配置要点
        1. 使用dataset.source配置数据源
        2. 通过encode配置数据映射
        3. 设置合适的radius和center
        4. 配置label显示格式
        5. 添加图例和提示框

        ### 柱状图配置要点
        1. 使用dataset.source配置数据源
        2. 通过encode配置x轴和y轴数据
        3. 设置合适的barWidth和barGap
        4. 配置坐标轴标签和刻度
        5. 添加数据标签和提示框

        ### 折线图配置要点
        1. 使用dataset.source配置数据源
        2. 通过encode配置x轴和y轴数据
        3. 设置合适的smooth和symbol
        4. 配置坐标轴标签和刻度
        5. 添加数据标签和提示框

        ## 配置生成要求
        1. 必须生成符合Echarts 4.X版本的完整配置项JSON
        2. 根据SQL语句分析出适合的维度和指标，智能匹配最合适的图表类型
        3. 使用dataset统一管理数据，通过encode配置数据映射
        4. 色彩方案：使用专业的数据可视化配色，确保色彩和谐且有足够对比度
        5. 设置合适的标题、图例、提示框等组件，提高图表可读性
        6. 数据标签：根据数据量和分布合理设置标签显示策略
        7. 坐标轴优化：设置合理的刻度、标签旋转角度和格式化
        8. 为大数据量场景优化：考虑数据抽样、缩放和滚动条等交互方式
        9. 针对时间序列数据，设置专业的时间轴格式和刻度
        10. 利用Echarts 4.X的特性添加适当的动画和交互效果

        ## 配置项示例结构
        ```json
{config_example}
        ```
        
        ## 回复格式
        1. 回复必须是JSON格式且仅包含Echarts 4.X配置，不要包含任何解释性文字
        2. 使用```json和```包裹你的JSON配置
        3. 确保配置是合法的JSON，不包含任何JavaScript函数，可以被JSON.parse()直接解析
        
        请基于以上信息，分析SQL语句中的维度和指标，参考用户需求，生成最适合的、符合Echarts 4.X版本的完整配置项，确保配置可直接用于前端渲染。配置中绝对不能包含任何JavaScript函数或无法通过JSON.parse()解析的内容。
        """

    @staticmethod
    def build_g2_config_prompt(sql: str, chart_type: str, user_request: str, datajson: str = None) -> str:
        """构建生成G2图表配置的提示词
        
        参数:
            sql (str): 统计SQL语句，可能包含多维度统计
            chart_type (str): 推荐图表类型，如"饼图"、"柱状图"等
            user_request (str): 用户输入的相关要求
            data_summary (str): 数据摘要信息，包含字段类型、数据范围等
            sample_data (str, optional): 前五行样本数据，JSON格式
            
        返回:
            str: 用于生成G2配置的提示词
        """
        
        try:
            # 简单解析 JSON 并获取前几条记录
            if datajson:
                data_list = json.loads(datajson)
                data_summary = DataHelp.get_data_summary(data_list)
                # 简单直接地获取前5条数据
                sample_data = json.dumps(data_list[:5] if isinstance(data_list, list) and len(data_list) > 0 else data_list, ensure_ascii=False)
            else:
                data_summary = "未提供数据"
                sample_data = "[]"
        except Exception as e:
            # 如果转换失败，返回简单的错误信息
            data_summary = f"数据处理失败: {str(e)}"
            sample_data = "[]"
            
        # 创建G2 5.0+版本的配置示例字符串
        config_example = '''{
         "type": "interval",
         "data": {
            "type": "fetch",
            "value": "dataSource"
         },
         "encode": {
            "x": "类别",
            "y": "数值",
            "color": "系列"
         },
         "scale": {
            "y": {"nice": true}
         },
         "axis": {
            "y": {"title": "数值单位"}
         },
         "style": {
            "radius": 4
         },
         "legend": {"position": "top"},
         "tooltip": {"items": [{"field": "类别"}, {"field": "数值"}]},
         "title": {"text": "图表标题", "subtext": "数据来源说明"},
         "animate": true
    
         }'''
        
        # 饼图的示例配置
        pie_example = '''{
          "type": "interval",
          "transform": [{ "type": "stackY" }],
          "coordinate": { "type": "theta", "innerRadius": 0 },
          "encode": {
            "y": "数值", 
            "color": "类别"
          },
          "style": { "stroke": "#fff", "lineWidth": 1 },
          "labels": [
            {
              "text": "类别",
              "position": "outside"
            },
            {
              "text": "百分比",
              "position": "inside"
            }
          ],
          "legend": { "position": "right" },
          "tooltip": { "items": [{ "field": "类别" }, { "field": "数值" }, { "field": "百分比" }] },
          "title": { "text": "饼图示例", "subtext": "数据分布" }
        }'''
        
        # 准备数据部分的提示
        data_instruction = ""
        if sample_data:
            data_instruction = f"""
            ## 样本数据 (用于理解数据结构)
            以下是查询结果的前五行数据，你应该根据这些样本数据理解字段结构：
            ```json
            {sample_data}
            ```
            """
        
        # 数据摘要信息
        summary_instruction = f"""
        ## 数据摘要信息
        {data_summary}
        
        注意事项:
        1. 使用数据摘要来理解整体数据结构和分布
        2. 样本数据仅用于理解字段名称和数据类型，不代表完整数据集
        3. 最终图表将使用完整的查询结果数据生成
        """
        
        return f"""
        # 角色设定：你是一位专业的数据可视化专家，精通G2图表库的5.0+版本配置和各类数据分析可视化

        ## 任务
        根据提供的SQL语句、数据摘要、样本数据和用户需求，生成适合G2 5.0+版本的配置项JSON，用于前端直接渲染图表。

        ## 输入数据分析
        1. SQL语句（可能包含多维度统计）: ```{sql}```
        2. 推荐图表类型: {chart_type}
        3. 用户需求: {user_request}
        {summary_instruction}
        {data_instruction}

        ## SQL分析步骤
        1. 解析SQL结构，识别SELECT字段列表、FROM子句、WHERE条件、GROUP BY分组、ORDER BY排序等
        2. 识别维度字段：通常是GROUP BY后的字段，或SELECT中非聚合函数字段
        3. 识别指标字段：通常是带聚合函数(SUM, AVG, COUNT等)的字段
        4. 分析WHERE条件，了解数据筛选范围
        5. 分析ORDER BY，确定数据的排序逻辑
        6. 检测是否包含HAVING子句，了解聚合后的过滤条件
        7. 检测是否包含子查询或UNION等复杂结构
        8. 判断是单维度分析还是多维度分析
        9. 识别时间相关字段，确定是否为时间序列分析

        ## G2 5.0+版本配置生成要求
        1. 必须生成符合G2 5.0+版本的完整配置项JSON
        2. 根据SQL语句分析出适合的维度和指标，智能匹配最合适的图表类型
        3. 使用G2 5.0+的声明式语法，正确设置type、data、encode等核心属性
        4. 颜色方案：使用专业的数据可视化配色，确保色彩和谐且有足够对比度
        5. 设置合适的标题、图例、提示框等组件，提高图表可读性
        6. 坐标轴优化：设置合理的刻度、标签旋转角度和格式化
        7. 根据数据类型设置合适的scale属性（如nice, padding等）
        8. 为大数据量场景优化：
           - 配置启用缩放功能，让用户可以放大查看特定区域
           - 为图例添加flipPage属性，处理图例项过多的情况
           - 考虑数据抽样或分页展示，避免渲染太多数据点影响性能
           - 对坐标轴标签进行旋转或省略处理，避免文本重叠
           - 用户需求中要求使用slider缩略轴组件时,才需要配置slider缩略轴组件,否则不要配置
           - 用户需求中要求使用scrollbar滚动条时,才需要配置scrollbar滚动条组件,否则不要配置

        ## ⚠️ 重要约束 ⚠️
        1. 绝对不要使用JavaScript函数语法，如 (d) => `${{d.字段}} (${{d.百分比}}%)`
        2. 所有配置必须是纯JSON格式，可以被JSON.parse()直接解析
        3. 对于需要使用函数的情况（如formatter），请使用字符串模板代替：
           - 错误示例：`"formatter": (d) => \`${{d.产品}} (${{d.比例}}%) \``
           - 正确示例：`"formatter": "{{产品}} ({{比例}}%)"`
        4. 避免使用以下非JSON标准的内容：
           - JavaScript函数
           - undefined值
           - 未闭合的引号或括号
           - 注释
           - 尾随逗号

        ## G2 5.0+图表类型选择指南
        ### 通用布局结构
        - 每个可视化元素直接设置 `type` 和 `encode` 属性
        - 配置可以直接包含图表元素及其属性，简化结构

        ### 适合比较类分析
        - 柱状图：使用 `type: "interval"` 搭配默认坐标系
        - 条形图：使用 `type: "interval"` 并交换 x、y 轴编码或调整坐标系方向
        - 分组柱状图：使用 `type: "interval"` 并设置 `dodgeX` 的 transform
        - 堆叠柱状图：使用 `type: "interval"` 并设置 `stackY` 的 transform

        ### 适合占比类分析
         - 饼图：使用 `type: "interval"` 搭配 `coordinate: {{ "type": "theta" }}` 和 `transform: [{{ "type": "stackY" }}]`
        - 环形图：与饼图类似，但设置 `innerRadius` 值 (如 0.6)
        - 玫瑰图：使用 `type: "interval"` 搭配 `coordinate: {{ "type": "polar" }}`
        - 矩形树图：使用 `type: "treemap"`

        ### 适合趋势类分析
        - 折线图：使用 `type: "line"`
        - 面积图：使用 `type: "area"`
        
        ### 适合分布分析
        - 散点图：使用 `type: "point"`
        - 热力图：使用 `type: "heatmap"`
        - 箱线图：使用 `type: "box"`

        ## 特殊数据处理建议
        1. 时间数据：设置合适的scale类型和格式化方式，使用字符串模板而非函数
        2. 百分比数据：使用字符串格式化模板，例如 `"formatter": "{{value}}%"`
        3. 金额数据：使用字符串格式化模板，例如 `"formatter": "¥{{value}}"`
        4. 大量类别：考虑top N + 其他分组，或启用图例滚动
        5. 多系列数据：使用明显区分的颜色和图例
        6. 异常值处理：设置outlier属性或自定义处理方式
        7. 不要对已用于位置编码（如 x/y）的字段重复使用 color

        ## G2 5.0+版本的重要特点
        1. 使用声明式语法，更强调数据与视觉通道的映射关系
        2. 简化的配置结构，直接使用图形元素的type（如interval、line、point等）
        3. 使用 `encode` 属性进行数据映射，而不是旧版的mapping
        4. 数据转换可以通过 `transform` 属性实现
        5. 交互配置通过 `interaction` 属性指定
        6. 支持通过 `label` 属性配置标签
        7. 可以使用扁平化结构，不需要嵌套层级，使配置更简洁

        ## 常见图表类型配置示例
        
        ### 柱状图示例
        ```json
{config_example}
        ```
        
        ### 饼图示例
        ```json
{pie_example}
        ```

        ## 格式化模板替代函数的方法
        G2 5.0+支持使用字符串模板而非JavaScript函数，以下是正确的示例：
        
        1. 百分比格式化：
           - 错误: `"formatter": (d) => \`${{d.value}}%\``
           - 正确: `"formatter": "{{value}}%"`
        
        2. 多字段组合：
           - 错误: `"formatter": (d) => \`${{d.category}}: ${{d.value}}\``
           - 正确: `"formatter": "{{category}}: {{value}}"`
        
        3. 货币格式化：
           - 错误: `"formatter": (d) => \`¥${{d.sales.toFixed(2)}}\`
           - 正确: `"formatter": "¥{{sales}}"
        
        ## 回复格式
        1. 回复必须是JSON格式且仅包含G2 5.0+版本的配置，不要包含任何解释性文字
        2. 使用```json和```包裹你的JSON配置
        3. 确保配置是合法的JSON，不包含任何JavaScript函数，可以被JSON.parse()直接解析
        
        请基于以上信息，分析SQL语句中的维度和指标，参考用户需求、数据摘要和样本数据，生成最适合的、符合G2 5.0+版本的完整配置项，确保配置可直接用于前端渲染。配置中绝对不能包含任何JavaScript函数、interaction配置项或无法通过JSON.parse()解析的内容。

        """

    @staticmethod
    def build_user_intent_prompt(table_info: str, user_input: str, history_messages: str = "") -> str:
        """
        构建用户意图分析提示词
        
        参数:
            table_structure (str): 当前表的结构信息
            user_input (str): 用户输入的信息/问题
            history_messages (str): 历史会话记录，默认为空字符串
        
        返回:
            str: 提示词
        """
        
          # 解析表结构JSON字符串
        try:
            # 获取列信息
            
            tablename=table_info.get("表名", "")
            column_names = table_info.get("列信息", [])
            
            # 使用表结构中的列类型分类（如果存在）
            column_types = table_info.get("列类型分类", {}) 
            numeric_cols = column_types.get("数值型列", [])
            date_cols = column_types.get("日期型列", [])
            text_cols = column_types.get("文本型列", [])
            # 尝试识别分类列（通常是文本列中的低基数列）
            category_cols = column_types.get("分类型列", []) 
            
            # 获取数据库类型
            db_type = table_info.get("数据库类型", "")
            db_description = table_info.get("数据库描述", "")
            # 获取表描述和SQL提示（如果存在）
            table_description = table_info.get("数据描述", "") 
           
              
        # 当前时间
            current_time = datetime.now().strftime("%Y-%m-%d")
        except (json.JSONDecodeError, Exception) as e:
            # 如果解析失败，使用默认值
            logger.error(f"解析表结构JSON失败: {str(e)}")
            column_names = []
            numeric_cols = []
            date_cols = []
            category_cols = []
            table_description = f"表 {tablename}"
            sql_hints = []
            db_type = "sqlite"
       
        
        # 图表类型映射示例
        chart_examples = """
        数据类型与推荐图表类型详细对应关系:
        1. 比例/占比数据
           - 饼图：适合5个以内的类别占比展示，强调部分与整体关系
           - 环形图：比饼图节省空间，中心可展示总数或核心信息
           - 玫瑰图：在展示占比的同时可体现数值大小差异
        
        2. 时间序列数据
           - 折线图：展示连续时间变化趋势，适合大量数据点
           - 面积图：强调累计量随时间变化，突出总量变化
           - 阶梯图：适合展示数值在特定时间点突变的数据
        
        3. 分类对比数据
           - 柱状图：垂直柱，适合少量分类的数值对比
           - 条形图：水平条，适合大量分类且类别名称较长的情况
           - 瀑布图：展示增减变化累积效果
        
        4. 多维分类数据
           - 堆叠柱状图：展示整体与部分的关系
           - 分组柱状图：适合多系列间的直接对比
           - 复合图表：组合柱状图和折线图，同时展示不同量级的数据
        
        5. 地理分布数据
           - 地图：基于地理坐标展示区域分布
           - 热力图：通过颜色深浅展示密度分布
        
        6. 相关性分析
           - 散点图：展示两个变量间的关系和分布
           - 气泡图：可同时展示三个维度的数据关系
        
        7. 分布情况
           - 箱线图：展示数据分布、离群值和四分位数
           - 直方图：展示数值分布密度
           - 漏斗图：展示转化率或流程各阶段数量变化
        """
        
        # 根据数据库类型选择不同的SQL规则
        sql_rules = ""
        
        # SQLite规则
        if db_type == "sqlite":
            sql_rules = """
            SQLite SQL语法规则:
            1. 日期处理函数
               - 日期格式化: strftime('%Y-%m-%d', date_column)
               - 按年分组: strftime('%Y', date_column)
               - 按月分组: strftime('%Y-%m', date_column)
               - 按日分组: strftime('%Y-%m-%d', date_column)
               - 当前日期: date('now')
               - 相对日期: date('now', '-1 month')
            
            2. 字符串处理
               - 字符串连接: column1 || ' ' || column2
               - 子字符串: substr(column, start, length)
               - 大小写: upper(column), lower(column)
            
            3. 条件表达式
               - CASE WHEN condition THEN result ELSE result END
            
            4. 分页
               - LIMIT number OFFSET number
               
            5. 字符串与数值转换
               - 字符串转数值: CAST(string_value AS INTEGER/REAL)
               - 数值转字符串: CAST(numeric_value AS TEXT)
               
            6. 聚合函数
               - SUM(), AVG(), MIN(), MAX(), COUNT()
               - GROUP_CONCAT(column, separator)
               
            7. GROUP BY规则
               - SELECT语句中的非聚合列必须出现在GROUP BY子句中
               - 例如：SELECT a, b, SUM(c) FROM table GROUP BY a, b
               - 或使用聚合函数：SELECT a, MAX(b), SUM(c) FROM table GROUP BY a
            """
        
        # MySQL规则
        elif db_type == "mysql":
            sql_rules = """
            MySQL SQL语法规则:
            1. 日期处理函数
               - 日期格式化: DATE_FORMAT(date_column, '%Y-%m-%d')
               - 年份提取: YEAR(date_column)
               - 月份提取: MONTH(date_column)
               - 按年月分组: DATE_FORMAT(date_column, '%Y-%m')
               - 当前日期: CURDATE()
               - 相对日期: DATE_SUB(CURDATE(), INTERVAL 1 MONTH)
            
            2. 字符串处理
               - 字符串连接: CONCAT(column1, ' ', column2)
               - 子字符串: SUBSTRING(column, start, length)
               - 大小写: UPPER(column), LOWER(column)
            
            3. 条件表达式
               - CASE WHEN condition THEN result ELSE result END
               - IF(condition, true_result, false_result)
            
            4. 分页
               - LIMIT offset, count
               - LIMIT count OFFSET offset
               
            5. 字符串与数值转换
               - 字符串转数值: CAST(string_value AS SIGNED/DECIMAL)
               - 数值转字符串: CAST(numeric_value AS CHAR)
               
            6. 聚合函数
               - SUM(), AVG(), MIN(), MAX(), COUNT()
               - GROUP_CONCAT(column SEPARATOR ',')
               
            7. GROUP BY规则 (ONLY_FULL_GROUP_BY模式下)
               - SELECT语句中的非聚合列必须出现在GROUP BY子句中
               - 错误示例: SELECT a, b, SUM(c) FROM table GROUP BY a
               - 正确示例: SELECT a, b, SUM(c) FROM table GROUP BY a, b
               - 如果不需要按b分组，则应使用聚合函数: SELECT a, MAX(b), SUM(c) FROM table GROUP BY a
               - 使用ANY_VALUE()函数可包含非分组字段: SELECT a, ANY_VALUE(b), SUM(c) FROM table GROUP BY a
            """
            
        # SQL Server规则
        elif db_type == "sqlserver" or db_type == "mssql":
            sql_rules = """
            SQL Server语法规则:
            1. 日期处理函数
               - 日期格式化: CONVERT(VARCHAR, date_column, 120) 或 CONVERT(VARCHAR, date_column, 23)
               - 年份提取: DATEPART(YEAR, date_column) 或 YEAR(date_column)
               - 月份提取: DATEPART(MONTH, date_column) 或 MONTH(date_column)
               - 日提取: DATEPART(DAY, date_column) 或 DAY(date_column)
               - 小时提取: DATEPART(HOUR, date_column)
               - 分钟提取: DATEPART(MINUTE, date_column) 
               - 秒提取: DATEPART(SECOND, date_column)
               - 按年月分组: CONVERT(VARCHAR(7), date_column, 120)
               - 当前日期: GETDATE()
               - 相对日期: DATEADD(month, -1, GETDATE())
               - 日期部分: DATEPART(year/month/day, date_column)
            
            2. 字符串处理
               - 字符串连接: column1 + ' ' + column2
               - 子字符串: SUBSTRING(column, start, length)
               - 大小写: UPPER(column), LOWER(column)
            
            3. 聚合函数: SUM(), AVG(), MIN(), MAX(), COUNT()
               - 字符串聚合: 使用FOR XML PATH('')实现字符串拼接
               
            4. 统计分析函数:
               - 排名: ROW_NUMBER() OVER(PARTITION BY column ORDER BY column)
               - 前N名: TOP n
            
            5. 分页:
               - SQL Server 2005+(使用ROW_NUMBER): 
                 WITH CTE AS (
                     SELECT ROW_NUMBER() OVER (ORDER BY order_column) AS RowNum, 
                            columns
                     FROM table
                     WHERE conditions
                 )
                 SELECT columns FROM CTE 
                 WHERE RowNum BETWEEN start_row AND end_row
               - 简单取前N条: TOP n
               
            6. 条件判断:
               - CASE WHEN condition THEN result ELSE result END
               - ISNULL(column, default_value)
               
            7. GROUP BY规则:
               - SELECT语句中的非聚合列必须出现在GROUP BY子句中
               - SELECT中的每个输出列必须是聚合函数结果，或者出现在GROUP BY子句中
               - 如果SELECT中包含复杂表达式，该表达式也必须完整地出现在GROUP BY中
               - 例如: SELECT CONVERT(VARCHAR(7), date_column, 120) AS month, SUM(sales)
                 FROM table GROUP BY CONVERT(VARCHAR(7), date_column, 120)
               - CASE表达式必须完整地出现在GROUP BY中
            """
            
            sql_examples = """
            1. 销售趋势分析：
               ```sql
               SELECT 
                 CONVERT(VARCHAR(7), 订单日期, 120) AS 月份, 
                 SUM(销售额) AS 月销售总额,
                 COUNT(DISTINCT 订单编号) AS 订单数量
               FROM {tablename}
               GROUP BY CONVERT(VARCHAR(7), 订单日期, 120)
               ORDER BY 月份
               ```
            
            2. 产品类别分析：
               ```sql
               SELECT 
                 产品类别, 
                 COUNT(*) AS 产品数量,
                 SUM(销售额) AS 类别销售额,
                 ROUND(SUM(销售额) * 100.0 / (SELECT SUM(销售额) FROM {tablename}), 2) AS 销售占比
               FROM {tablename}
               GROUP BY 产品类别
               ORDER BY SUM(销售额) DESC
               ```
               
            3. 客户购买频次分析：
               ```sql
               SELECT TOP 10
                 客户名称,
                 COUNT(*) AS 订单数,
                 SUM(销售额) AS 总消费,
                 SUM(销售额)/COUNT(*) AS 客单价
               FROM {tablename}
               GROUP BY 客户名称
               ORDER BY COUNT(*) DESC
               ```
               
            4. 按小时分析订单量：
               ```sql
               SELECT 
                 DATEPART(HOUR, 订单时间) AS 小时段,
                 COUNT(*) AS 订单数量
               FROM {tablename}
               GROUP BY DATEPART(HOUR, 订单时间)
               ORDER BY 小时段
               ```
            """
            
        # PostgreSQL规则
        elif db_type == "postgresql" or db_type == "postgres":
            sql_rules = """
            PostgreSQL语法规则:
            1. 日期处理函数
               - 日期格式化: TO_CHAR(date_column, 'YYYY-MM-DD')
               - 年份提取: EXTRACT(YEAR FROM date_column)
               - 月份提取: EXTRACT(MONTH FROM date_column)
               - 按年月分组: TO_CHAR(date_column, 'YYYY-MM')
               - 当前日期: CURRENT_DATE
               - 相对日期: CURRENT_DATE - INTERVAL '1 month'
            
            2. 字符串处理
               - 字符串连接: column1 || ' ' || column2
               - 子字符串: SUBSTRING(column FROM start FOR length)
               - 大小写: UPPER(column), LOWER(column)
            
            3. 聚合函数: SUM(), AVG(), MIN(), MAX(), COUNT()
               - STRING_AGG(column, ',')
            
            4. 分页: LIMIT count OFFSET offset
            
            5. GROUP BY规则:
               - SELECT语句中的非聚合列必须出现在GROUP BY子句中
               - PostgreSQL强制执行"only_full_group_by"规则
               - 如果SELECT中包含复杂表达式，该表达式也必须完整地出现在GROUP BY中
               - 例如: SELECT TO_CHAR(date_column, 'YYYY-MM') AS month, SUM(sales)
                 FROM table GROUP BY TO_CHAR(date_column, 'YYYY-MM')
               - 可以使用聚合函数例如 MAX(), MIN()等包含不需要分组的字段
            """
            
            sql_examples = """
            1. 销售趋势分析：
               ```sql
               SELECT 
                 TO_CHAR(订单日期, 'YYYY-MM') AS 月份, 
                 SUM(销售额) AS 月销售总额,
                 COUNT(DISTINCT 订单编号) AS 订单数量
               FROM {tablename}
               GROUP BY TO_CHAR(订单日期, 'YYYY-MM')
               ORDER BY 月份
               ```
            
            2. 产品类别分析：
               ```sql
               SELECT 
                 产品类别, 
                 COUNT(*) AS 产品数量,
                 SUM(销售额) AS 类别销售额,
                 ROUND(SUM(销售额) * 100.0 / (SELECT SUM(销售额) FROM {tablename}), 2) AS 销售占比
               FROM {tablename}
               GROUP BY 产品类别
               ORDER BY 类别销售额 DESC
               ```
               
            3. 客户购买频次分析：
               ```sql
               SELECT 
                 客户名称,
                 COUNT(*) AS 订单数,
                 SUM(销售额) AS 总消费,
                 ROUND(SUM(销售额)/COUNT(*), 2) AS 客单价
               FROM {tablename}
               GROUP BY 客户名称
               ORDER BY 订单数 DESC
               LIMIT 10
               ```
            """
            
        # Oracle规则
        elif db_type == "oracle":
            sql_rules = """
            Oracle SQL语法规则:
            1. 日期处理函数
               - 日期格式化: TO_CHAR(date_column, 'YYYY-MM-DD')
               - 年份提取: EXTRACT(YEAR FROM date_column)
               - 月份提取: EXTRACT(MONTH FROM date_column)
               - 按年月分组: TO_CHAR(date_column, 'YYYY-MM')
               - 当前日期: SYSDATE, CURRENT_DATE
               - 相对日期: ADD_MONTHS(SYSDATE, -1)
            
            2. 字符串处理
               - 字符串连接: column1 || ' ' || column2
               - 子字符串: SUBSTR(column, start, length)
               - 大小写: UPPER(column), LOWER(column)
            
            3. 聚合函数: SUM(), AVG(), MIN(), MAX(), COUNT()
               - LISTAGG(column, ',') WITHIN GROUP (ORDER BY column)
            
            4. 分页:
               - 使用ROWNUM: SELECT * FROM (YOUR_QUERY) WHERE ROWNUM <= n
               - 12c及以上版本: OFFSET offset ROWS FETCH NEXT count ROWS ONLY
               
            5. GROUP BY规则:
               - SELECT语句中的非聚合列必须出现在GROUP BY子句中
               - 如果SELECT中包含复杂表达式，该表达式也必须完整地出现在GROUP BY中
               - 例如: SELECT TO_CHAR(date_column, 'YYYY-MM') AS month, SUM(sales)
                 FROM table GROUP BY TO_CHAR(date_column, 'YYYY-MM')
               - 对于CASE表达式，整个表达式必须出现在GROUP BY中
            """
            
            sql_examples = """
            1. 销售趋势分析：
               ```sql
               SELECT 
                 TO_CHAR(订单日期, 'YYYY-MM') AS 月份, 
                 SUM(销售额) AS 月销售总额,
                 COUNT(DISTINCT 订单编号) AS 订单数量
               FROM {tablename}
               GROUP BY TO_CHAR(订单日期, 'YYYY-MM')
               ORDER BY 月份
               ```
            
            2. 产品类别分析：
               ```sql
               SELECT 
                 产品类别, 
                 COUNT(*) AS 产品数量,
                 SUM(销售额) AS 类别销售额,
                 ROUND(SUM(销售额) * 100.0 / (SELECT SUM(销售额) FROM {tablename}), 2) AS 销售占比
               FROM {tablename}
               GROUP BY 产品类别
               ORDER BY SUM(销售额) DESC
               ```
               
            3. 客户购买频次分析：
               ```sql
               SELECT *
               FROM (
                 SELECT 
                   客户名称,
                   COUNT(*) AS 订单数,
                   SUM(销售额) AS 总消费,
                   SUM(销售额)/COUNT(*) AS 客单价
                 FROM {tablename}
                 GROUP BY 客户名称
                 ORDER BY COUNT(*) DESC
               )
               WHERE ROWNUM <= 10
               ```
            """
        else:  # 默认使用通用SQL语法规则
            sql_rules = """
            通用SQL语法规则:
            1. 确保每个SQL语句语法完全正确，并可直接执行
            2. 优先使用标准SQL语法，确保兼容性
            3. 使用适当的注释提高可读性
            4. 确保GROUP BY子句包含所有非聚合字段
               - 在SELECT列表中的所有非聚合列必须出现在GROUP BY子句中
               - 错误示例: SELECT column1, column2, SUM(column3) FROM table GROUP BY column1
               - 正确示例: SELECT column1, column2, SUM(column3) FROM table GROUP BY column1, column2
               - 如果不需要按某列分组，应使用聚合函数: SELECT column1, MAX(column2), SUM(column3) FROM table GROUP BY column1
            5. 输出格式依据需求使用别名和正确的显示名称
            6. 避免除零错误
            7. 根据用户需求添加适当的ORDER BY和LIMIT子句
            """
            
            sql_examples = """
            1. 销售趋势分析：
               ```sql
               SELECT 
                 订单日期 AS 月份, 
                 SUM(销售额) AS 月销售总额,
                 COUNT(DISTINCT 订单编号) AS 订单数量
               FROM {tablename}
               GROUP BY 月份
               ORDER BY 月份
               ```
            
            2. 产品类别分析：
               ```sql
               SELECT 
                 产品类别, 
                 COUNT(*) AS A产品数量,
                 SUM(销售额) AS 类别销售额,
                 ROUND(SUM(销售额) * 100.0 / (SELECT SUM(销售额) FROM {tablename}), 2) AS 销售占比
               FROM {tablename}
               GROUP BY 产品类别
               ORDER BY 类别销售额 DESC
               ```
            """
        
        # 意图识别参考示例，根据数据库类型进行调整
        intent_examples = ""
        
        if db_type == "sqlite":
            intent_examples = """
            意图识别详细示例(SQLite):
            
            1. 查询数据意图:
               用户输入: "显示销售额最高的10个客户"
               主要意图: 查询数据
               其它意图: 数据排序、限制数量
               SQL示例: SELECT 客户名称, SUM(销售额) AS 总销售额 FROM table GROUP BY 客户名称 ORDER BY 总销售额 DESC LIMIT 10;
               
            2. 分析数据意图:
               用户输入: "分析不同地区的销售情况，用饼图展示"
               主要意图: 分析数据
               其它意图: 使用饼图展示、按地区分组
               SQL示例: SELECT 地区, SUM(销售额) AS 地区销售额, ROUND(SUM(销售额) * 100.0 / (SELECT SUM(销售额) FROM table), 2) AS 销售占比 FROM table GROUP BY 地区 ORDER BY 地区销售额 DESC;
               
            3. 复合意图:
               用户输入: "对比2022年和2023年各季度销售额，用柱状图展示"
               主要意图: 分析数据
               其它意图: 时间比较、季度分析、使用柱状图展示
               SQL示例:
               SELECT
                 strftime('%Y', 日期) AS 年份,
                 CASE
                   WHEN strftime('%m', 日期) BETWEEN '01' AND '03' THEN 'Q1'
                   WHEN strftime('%m', 日期) BETWEEN '04' AND '06' THEN 'Q2'
                   WHEN strftime('%m', 日期) BETWEEN '07' AND '09' THEN 'Q3'
                   ELSE 'Q4'
                 END AS 季度,
                 SUM(销售额) AS 季度销售额
               FROM table
               WHERE strftime('%Y', 日期) IN ('2022', '2023')
               GROUP BY 年份, 季度
               ORDER BY 年份, 季度;
            """
        elif db_type == "mysql":
            intent_examples = """
            意图识别详细示例(MySQL):
            
            1. 查询数据意图:
               用户输入: "显示销售额最高的10个客户"
               主要意图: 查询数据
               其它意图: 数据排序、限制数量
               SQL示例: SELECT 客户名称, SUM(销售额) AS 总销售额 FROM table GROUP BY 客户名称 ORDER BY 总销售额 DESC LIMIT 10;
               
            2. 分析数据意图:
               用户输入: "分析不同地区的销售情况，用饼图展示"
               主要意图: 分析数据
               其它意图: 使用饼图展示、按地区分组
               SQL示例: SELECT 地区, SUM(销售额) AS 地区销售额, ROUND(SUM(销售额) * 100.0 / (SELECT SUM(销售额) FROM table), 2) AS 销售占比 FROM table GROUP BY 地区 ORDER BY 地区销售额 DESC;
               
            3. 复合意图:
               用户输入: "对比2022年和2023年各季度销售额，用柱状图展示"
               主要意图: 分析数据
               其它意图: 时间比较、季度分析、使用柱状图展示
               SQL示例:
               SELECT
                 YEAR(日期) AS 年份,
                 CASE
                   WHEN MONTH(日期) BETWEEN 1 AND 3 THEN 'Q1'
                   WHEN MONTH(日期) BETWEEN 4 AND 6 THEN 'Q2'
                   WHEN MONTH(日期) BETWEEN 7 AND 9 THEN 'Q3'
                   ELSE 'Q4'
                 END AS 季度,
                 SUM(销售额) AS 季度销售额
               FROM table
               WHERE YEAR(日期) IN (2022, 2023)
               GROUP BY 年份, 季度
               ORDER BY 年份, 季度;
            """
        elif db_type == "sqlserver" or db_type == "mssql":
            intent_examples = """
            意图识别详细示例(SQL Server):
            
            1. 查询数据意图:
               用户输入: "显示销售额最高的10个客户"
               主要意图: 查询数据
               其它意图: 数据排序、限制数量
               SQL示例: SELECT TOP 10 客户名称, SUM(销售额) AS 总销售额 FROM table GROUP BY 客户名称 ORDER BY 总销售额 DESC;
               
               -- SQL Server 2005分页示例 (获取第11-20条记录):
               SQL示例: 
               WITH CTE AS (
                   SELECT ROW_NUMBER() OVER (ORDER BY SUM(销售额) DESC) AS RowNum,
                          客户名称, SUM(销售额) AS 总销售额 
                   FROM table 
                   GROUP BY 客户名称
               )
               SELECT 客户名称, 总销售额 
               FROM CTE 
               WHERE RowNum BETWEEN 11 AND 20;
               
            2. 分析数据意图:
               用户输入: "分析不同地区的销售情况，用饼图展示"
               主要意图: 分析数据
               其它意图: 使用饼图展示、按地区分组
               SQL示例: SELECT 地区, SUM(销售额) AS 地区销售额, ROUND(SUM(销售额) * 100.0 / (SELECT SUM(销售额) FROM table), 2) AS 销售占比 FROM table GROUP BY 地区 ORDER BY 地区销售额 DESC;
               
            3. 复合意图:
               用户输入: "对比2022年和2023年各季度销售额，用柱状图展示"
               主要意图: 分析数据
               其它意图: 时间比较、季度分析、使用柱状图展示
               SQL示例:
               SELECT
                 YEAR(日期) AS 年份,
                 CASE
                   WHEN MONTH(日期) BETWEEN 1 AND 3 THEN 'Q1'
                   WHEN MONTH(日期) BETWEEN 4 AND 6 THEN 'Q2'
                   WHEN MONTH(日期) BETWEEN 7 AND 9 THEN 'Q3'
                   ELSE 'Q4'
                 END AS 季度,
                 SUM(销售额) AS 季度销售额
               FROM table
               WHERE YEAR(日期) IN (2022, 2023)
               GROUP BY YEAR(日期), 
                        CASE
                          WHEN MONTH(日期) BETWEEN 1 AND 3 THEN 'Q1'
                          WHEN MONTH(日期) BETWEEN 4 AND 6 THEN 'Q2'
                          WHEN MONTH(日期) BETWEEN 7 AND 9 THEN 'Q3'
                          ELSE 'Q4'
                        END
               ORDER BY 年份, 季度;
            """
        elif db_type == "postgresql" or db_type == "postgres":
            intent_examples = """
            意图识别详细示例(PostgreSQL):
            
            1. 查询数据意图:
               用户输入: "显示销售额最高的10个客户"
               主要意图: 查询数据
               其它意图: 数据排序、限制数量
               SQL示例: SELECT 客户名称, SUM(销售额) AS 总销售额 FROM table GROUP BY 客户名称 ORDER BY 总销售额 DESC LIMIT 10;
               
            2. 分析数据意图:
               用户输入: "分析不同地区的销售情况，用饼图展示"
               主要意图: 分析数据
               其它意图: 使用饼图展示、按地区分组
               SQL示例: SELECT 地区, SUM(销售额) AS 地区销售额, ROUND(SUM(销售额) * 100.0 / (SELECT SUM(销售额) FROM table), 2) AS 销售占比 FROM table GROUP BY 地区 ORDER BY 地区销售额 DESC;
               
            3. 复合意图:
               用户输入: "对比2022年和2023年各季度销售额，用柱状图展示"
               主要意图: 分析数据
               其它意图: 时间比较、季度分析、使用柱状图展示
               SQL示例:
               SELECT
                 EXTRACT(YEAR FROM 日期) AS 年份,
                 CASE
                   WHEN EXTRACT(MONTH FROM 日期) BETWEEN 1 AND 3 THEN 'Q1'
                   WHEN EXTRACT(MONTH FROM 日期) BETWEEN 4 AND 6 THEN 'Q2'
                   WHEN EXTRACT(MONTH FROM 日期) BETWEEN 7 AND 9 THEN 'Q3'
                   ELSE 'Q4'
                 END AS 季度,
                 SUM(销售额) AS 季度销售额
               FROM table
               WHERE EXTRACT(YEAR FROM 日期) IN (2022, 2023)
               GROUP BY 年份, 季度
               ORDER BY 年份, 季度;
            """
        elif db_type == "oracle":
            intent_examples = """
            意图识别详细示例(Oracle):
            
            1. 查询数据意图:
               用户输入: "显示销售额最高的10个客户"
               主要意图: 查询数据
               其它意图: 数据排序、限制数量
               SQL示例: SELECT 客户名称, SUM(销售额) AS 总销售额 FROM table GROUP BY 客户名称 ORDER BY 总销售额 DESC FETCH FIRST 10 ROWS ONLY;
               
            2. 分析数据意图:
               用户输入: "分析不同地区的销售情况，用饼图展示"
               主要意图: 分析数据
               其它意图: 使用饼图展示、按地区分组
               SQL示例: SELECT 地区, SUM(销售额) AS 地区销售额, ROUND(SUM(销售额) * 100.0 / (SELECT SUM(销售额) FROM table), 2) AS 销售占比 FROM table GROUP BY 地区 ORDER BY 地区销售额 DESC;
               
            3. 复合意图:
               用户输入: "对比2022年和2023年各季度销售额，用柱状图展示"
               主要意图: 分析数据
               其它意图: 时间比较、季度分析、使用柱状图展示
               SQL示例:
               SELECT
                 EXTRACT(YEAR FROM 日期) AS 年份,
                 CASE
                   WHEN EXTRACT(MONTH FROM 日期) BETWEEN 1 AND 3 THEN 'Q1'
                   WHEN EXTRACT(MONTH FROM 日期) BETWEEN 4 AND 6 THEN 'Q2'
                   WHEN EXTRACT(MONTH FROM 日期) BETWEEN 7 AND 9 THEN 'Q3'
                   ELSE 'Q4'
                 END AS 季度,
                 SUM(销售额) AS 季度销售额
               FROM table
               WHERE EXTRACT(YEAR FROM 日期) IN (2022, 2023)
               GROUP BY EXTRACT(YEAR FROM 日期),
                        CASE
                          WHEN EXTRACT(MONTH FROM 日期) BETWEEN 1 AND 3 THEN 'Q1'
                          WHEN EXTRACT(MONTH FROM 日期) BETWEEN 4 AND 6 THEN 'Q2'
                          WHEN EXTRACT(MONTH FROM 日期) BETWEEN 7 AND 9 THEN 'Q3'
                          ELSE 'Q4'
                        END
               ORDER BY 年份, 季度;
            """
        else:
            intent_examples = """
            意图识别详细示例:
            
            1. 查询数据意图:
               用户输入: "显示销售额最高的10个客户"
               主要意图: 查询数据
               其它意图: 数据排序、限制数量
               SQL示例: SELECT 客户名称, SUM(销售额) AS 总销售额 FROM table GROUP BY 客户名称 ORDER BY 总销售额 DESC LIMIT 10;
               
            2. 分析数据意图:
               用户输入: "分析不同地区的销售情况，用饼图展示"
               主要意图: 分析数据
               其它意图: 使用饼图展示、按地区分组
               SQL示例: SELECT 地区, SUM(销售额) AS 地区销售额, ROUND(SUM(销售额) * 100.0 / (SELECT SUM(销售额) FROM table), 2) AS 销售占比 FROM table GROUP BY 地区 ORDER BY 地区销售额 DESC;
               
            3. 意图不明:
               用户输入: "我想看看销售情况"
               主要意图: 意图不明
               需求确认信息: "您希望查看哪个时间段的销售情况？是想了解总体销售趋势，还是各产品类别的销售分布？"
               
            4. 复合意图:
               用户输入: "对比2022年和2023年各季度销售额，用柱状图展示"
               主要意图: 分析数据
               其它意图: 时间比较、季度分析、使用柱状图展示
               SQL示例: (根据具体数据库类型提供相应语法)
            """
        
        # 构建完整提示词
        return f"""
        你是一位精通{db_type.upper()}数据库和数据分析的专业数据分析师，需要精确分析用户输入的查询需求，并根据表结构生成准确的SQL查询语句。
        
        # 当前上下文信息
        历史会话: {history_messages}
        
        # 表结构信息
        - 表名: {tablename}
        - 表描述: {table_description}
        - 所有列: {column_names}
        - 可能的数值列: {numeric_cols}
        - 可能的日期列: {date_cols}
        - 可能的分类列: {category_cols}
        - 当前日期: {current_time}
        - 数据库类型: {db_type}
        - 数据库描述: {db_description}
        
        # 参考知识
        {chart_examples}
        {sql_rules}
        {intent_examples}
        
        # 任务描述
        分析用户输入: "{user_input}"，完成以下任务:
        
        1. 识别用户主要意图，必须归类为以下三类之一:
           - "查询数据": 用户想获取原始数据或简单统计结果
           - "分析数据": 用户希望对数据进行深入分析、挖掘洞察
           - "意图不明": 用户输入不明确或无法确定具体意图
           
        2. 识别用户其它意图，如:
           - 特定的展示方式需求(如"用饼图展示")
           - 数据筛选条件(如"去年的"、"销售额大于1000的")
           - 排序要求(如"按销售额排序"、"前10名")
           - 限制数量要求(如"显示前5个")
           - 分组需求(如"按月统计"、"按地区分布")
           - 计算需求(如"计算增长率"、"占比分析")
           
        3. 根据意图类型生成响应:
           - 若是"查询数据"或"分析数据"意图:
             * 提供完成用户意图所需的数据源信息
             * 为每个数据源生成精确的{db_type.upper()}SQL语句(包含筛选条件、分组、排序等)
             * 推荐最合适的图表类型(基于数据特征和用户需求)
           - 若是"意图不明":
             * 根据历史会话和表结构生成明确且有针对性的需求确认信息
        
        # SQL生成关键规则
        1. 字段准确性
           - 严格使用表中实际存在的字段名，不得使用不存在的字段
           - 当用户提到的字段名与实际字段不完全匹配时，选择最接近的字段
           
        2. SQL语法准确性
           - 确保每个SQL语句语法完全正确，并可直接在{db_type.upper()}中执行
           - 在GROUP BY子句中必须包含SELECT列表中所有非聚合字段
           - 如果SELECT中有非聚合字段没有出现在GROUP BY中，则必须对其使用聚合函数(如MAX, MIN, ANY_VALUE等)
           - 对于复杂表达式，如CASE语句、日期格式化函数等，如果它们出现在SELECT中，也必须完整地出现在GROUP BY中
           - 输出格式依据需求使用别名和正确的显示名称
           - 确保所有SQL关键词（如SELECT, FROM, WHERE, JOIN, GROUP BY等）前后都有空格
           - 特别注意FROM、JOIN、INTO、UPDATE等关键词后必须有空格再接表名
           - 确保表名和WHERE之间有空格，如"table_name WHERE"而非"table_nameWHERE"
           - 确保条件语句和GROUP BY, ORDER BY之间有空格，如"条件 GROUP BY"而非"条件GROUP BY"
        
        3. 日期处理
           - 使用{db_type.upper()}的日期函数处理所有日期相关查询
           - 正确处理"本月"、"上季度"、"去年"等相对时间表述
           - 如果SELECT中使用日期格式化或提取函数，必须在GROUP BY中使用相同的表达式
           
        4. 数值计算
           - 使用正确的聚合函数(SUM, AVG, COUNT等)
           - 计算占比时使用子查询或窗口函数确保准确性
           - 避免除零错误
           
        5. 排序和限制
           - 根据用户需求添加适当的ORDER BY和{db_type.upper()}特有的分页/限制子句
           - 确保排序方向(ASC/DESC)符合用户期望
        
        # GROUP BY特别注意事项 (适用于ONLY_FULL_GROUP_BY模式)
        1. 必须确保SELECT语句中的每个非聚合列都出现在GROUP BY子句中
           - 错误示例: SELECT a, b, SUM(c) FROM table GROUP BY a
           - 正确示例: SELECT a, b, SUM(c) FROM table GROUP BY a, b
        
        2. 复杂表达式处理
           - 如果SELECT中使用了表达式(如CASE语句或函数调用)，在GROUP BY中必须使用完全相同的表达式
           - 例如: SELECT YEAR(date_col), SUM(sales) FROM table GROUP BY YEAR(date_col)
        
        3. 非分组字段处理方法
           - 对不需要分组但又想在结果中显示的字段，使用聚合函数:
             * MySQL: SELECT group_col, ANY_VALUE(non_group_col), SUM(value) FROM table GROUP BY group_col
             * 其他数据库: SELECT group_col, MAX(non_group_col), SUM(value) FROM table GROUP BY group_col
           - 或者将额外字段加入GROUP BY:
             * SELECT group_col, extra_col, SUM(value) FROM table GROUP BY group_col, extra_col
        
        # 输出格式要求
        必须严格按照以下JSON格式输出，且确保是有效的JSON:
        ```json
        [{{
          "用户主要意图": "查询数据|分析数据|意图不明",
          "用户其它意图": "用户其它意图的详细描述",
          "需求确认信息": "当意图不明时，提供的确认信息",
          "数据源信息": [
            {{
              "数据源名称": "根据用户意图命名的数据源",
              "推荐图表类型": "适合展示该数据的图表类型",
              "SQL": "获取该数据的{db_type.upper()}SQL语句",
              "SQL说明": "SQL语句的中文说明,方便普通用户理解"
            }}
          ]
        }}]
        ```
        
        注意事项:
        1. 如果意图是"查询数据"或"分析数据"，"需求确认信息"应为空字符串
        2. 如果意图是"意图不明"，"数据源信息"应为空数组
        3. 确保SQL语句语法100%正确且符合{db_type.upper()}标准，特别是GROUP BY规则
        4. SQL语句必须只使用表中存在的字段，不得假设存在任何未在表结构中列出的字段
        5. 只在有明确图表需求时推荐特定图表类型，否则根据数据特性推荐最合适的可视化方式
        6. 禁止在输出中包含任何解释性文字，仅输出符合格式的JSON
        7. 推荐的图表类型应从以下选择：饼图、折线图、柱状图、条形图、散点图、面积图、堆叠柱状图、热力图
        8. 每个SQL语句必须以分号结尾
        9. SQL数量不能超过3个
        10. 确保数据源名称清晰描述该数据的主要内容和用途
        
        ==== SQL格式化规则 ====
        1. SQL语句中必须避免使用换行符(\n)和回车符(\r)，应当使用空格代替
        2. SQL关键词之间应当使用单个空格分隔，避免多个连续空格
        3. 所有SQL关键词(SELECT, FROM, WHERE等)前后必须有空格，例如:
           - 正确: "SELECT * FROM table WHERE column = value"
           - 错误: "SELECT*FROM table WHEREcolumn=value"
        4. 特别注意表名和条件关键词之间的空格:
           - 正确: "FROM users WHERE id = 1"
           - 错误: "FROM usersWHERE id = 1"
        5. 条件语句和GROUP BY/ORDER BY之间必须有空格:
           - 正确: "WHERE date > '2023-01-01' GROUP BY category"
           - 错误: "WHERE date > '2023-01-01'GROUP BY category"
        
        ==== 输出JSON格式规则 ====
        1. 使用双引号包裹所有key，禁止单引号
        2. 数值不加引号，字符串必须加双引号
        3. 转义特殊字符：如`\n`变为`\\n`，SQL语句中不应该包含原始的换行符
        4. 包含单引号的名称需转义为双单引号
        5. SQL字段中如果包含特殊字符，应正确处理以避免语法错误
        
        务必确保生成的JSON格式正确，可被JSON.parse()解析。输出必须是严格遵循模式的有效JSON，不包含任何额外注释。
        """

    @staticmethod
    def build_data_summary_report_prompt(data_summary_json: str) -> str:
        """构建用于生成数据摘要报告的提示词
        
        参数:
            data_summary_json (str): JSON 格式的数据摘要信息
            
        返回:
            str: 用于生成数据摘要报告的提示词
        """
        return f"""
        # 任务：将技术性数据摘要转化为普通用户能理解的数据概览报告

        ## 数据摘要信息
        ```json
        {data_summary_json}
        ```

        ## 背景
        你是一位专业的数据分析师，需要向非技术背景的业务用户解释这份数据的基本情况。
        用户不熟悉技术术语，需要通俗易懂的解释。

        ## 要求
        1. 用简单的语言解释数据的基本情况（行数、列数、数据类型分布等）
        2. 为每种类型的数据列提供见解：
           - 数值型列：解释数值范围、平均值、分布特点等
           - 类别型列：解释主要类别及其分布
           - 日期型列：解释时间跨度及特点
           - 文本型列：解释可能的用途
        3. 指出数据的主要特点和可能的分析价值
        4. 提出2-3个基于此数据可能进行的分析方向
        5. 指出数据质量问题（如缺失值、异常值）及其可能的影响
        
        ## 输出格式
        - 使用标题、小标题组织内容
        - 使用简单的语言，避免技术术语
        - 使用要点符号列表呈现关键信息
        - 内容篇幅适中，不超过800字
        - 可以适当使用比喻来解释复杂概念

        ## 报告标题
        【数据概览报告】
        """
        
    @staticmethod
    def build_data_cleaning_report_prompt(cleaning_log_json: str) -> str:
        """
        构建数据清洗报告提示词
        
        参数:
            cleaning_log_json (str): 清洗日志JSON字符串
            
        返回:
            str: 提示词字符串
        """
        return f"""
        # 任务背景
        你是一位数据清洗报告专家，需要根据提供的清洗日志JSON，生成一份详细、专业且易于理解的数据清洗报告。

        # 清洗日志JSON
            ```json
            {cleaning_log_json}
            ```

        # 报告要求
        1. 报告结构清晰，包含以下部分：
            - 清洗概述：简要概述数据清洗的范围、目标和主要成果
            - 数据概况：原始数据的基本情况（行数、列数、数据类型等）
            - 清洗过程：详细说明每个清洗步骤的目的、方法和结果
            - 清洗统计：汇总清洗效果（如修复的缺失值数量、处理的异常值数量等）
            - 数据质量改善：量化数据质量改善程度
            - 建议：对后续数据处理和收集的建议（如有）

        2. 报告风格要求：
            - 使用专业的数据科学术语
            - 条理清晰，逻辑连贯
            - 适当使用图表标记语言描述清洗结果
            - 避免过度技术性的描述，保证业务人员也能理解
            - 使用准确的数据和百分比来量化清洗效果

        # 注意事项
        - 完整解析JSON中的所有内容，不遗漏任何清洗步骤
        - 对每个清洗操作的必要性进行简短解释
        - 使用准确的术语描述数据问题和解决方案
        - 可以使用Markdown格式增强报告的可读性
        - 报告篇幅适中，字数在800-1500字之间
        
        请根据以上要求，生成一份专业的数据清洗报告。
        """
        
    @staticmethod
    def build_data_interpretation_prompt(table_info: dict, analysis_data: str, dimension_info) -> str:
        """
        构建数据解读提示词，用于生成对数据的专业分析
        
        参数:
            table_info (dict): 表结构信息，包含列名、数据类型等
            analysis_data (str): 分析数据JSON字符串
            dimension_info (dict): 维度信息，包含分析维度名称、描述、目标等
            
        返回:
            str: 提示词字符串
        """
        # 提取维度信息
        dimension_name = dimension_info.get('dimension_name', '未命名维度')
        dimension_description = dimension_info.get('dimension_description', '无描述')
        
        # 提取用户意见
        answerable_questions = dimension_info.get('answerable_questions', '')
        
        try:
            # 获取列信息
            
            tablename=table_info.get("表名", "")
            column_names = table_info.get("列信息", [])
            
            # 使用表结构中的列类型分类（如果存在）
            column_types = table_info.get("列类型分类", {}) 
            numeric_cols = column_types.get("数值型列", [])
            date_cols = column_types.get("日期型列", [])
            text_cols = column_types.get("文本型列", [])
            # 尝试识别分类列（通常是文本列中的低基数列）
            category_cols = column_types.get("分类型列", []) 
            
            # 获取数据库类型
            db_type = table_info.get("数据库类型", "")

            # 获取表描述和SQL提示（如果存在）
            table_description = table_info.get("表描述", "") 
           
              
            # 当前时间
            current_time = datetime.now().strftime("%Y-%m-%d")
        except (json.JSONDecodeError, Exception) as e:
            # 如果解析失败，使用默认值
            logger.error(f"解析表结构JSON失败: {str(e)}")
            column_names = []
            numeric_cols = []
            date_cols = []
            category_cols = []
            table_description = f"表 {tablename}"
            db_type = "sqlite"

        # 检查数据量
        data_size_warning = ""
        try:
            # 尝试解析JSON数据
            import json
            data = json.loads(analysis_data) if isinstance(analysis_data, str) else analysis_data
            
            # 如果是列表数据，检查行数
            if isinstance(data, list):
                row_count = len(data)
                if row_count > 200:
                    data_size_warning = f"⚠️ 注意：数据行数({row_count})超过200行，请仅基于前200行数据进行分析，或考虑使用聚合摘要方法。"
        except:
            data_size_warning = "⚠️ 注意：无法解析数据JSON格式或计算数据量，请谨慎分析。"
        
        return f"""
        # 数据分析解读生成任务
        
        ## 任务概述
        你是一位专业的数据分析师，需要针对特定分析维度，对提供的数据进行深入解读，生成一段专业、有洞察力的分析文本。这段文本将作为完整数据分析报告的一部分。
        
        ## 分析维度信息
        - **维度名称**: {dimension_name}
        - **维度描述**: {dimension_description}
        
        ## 用户特定需求
        {answerable_questions}
        
        ## 表结构信息
        - 表名: {tablename}
        - 表描述: {table_description}
        - 所有列: {column_names}
        - 可能的数值列: {numeric_cols}
        - 可能的日期列: {date_cols}
        - 可能的分类列: {category_cols}
        - 当前日期: {current_time}
        - 数据库类型: {db_type}
        
        ## 分析数据
        ```json
        {analysis_data}
        ```
        
        {data_size_warning}
        
        ## 解读要求
        1. **优先考虑用户需求**:
           - 必须首先考虑用户特定需求(answerable_questions)中的指示
           - 注意用户需求中的字数限制（如"分析不超过50字"、"简短回复"等）
           - 遵循内容限制（如"只关注销售额"、"仅分析近30天数据"等）
           - 按照格式限制（如"以列表形式"、"需要表格"等）
           - 符合深度限制（如"简要概述"、"深入分析"等）
        
        2. **默认输出结构**:
           - 必须使用Markdown格式输出
           - **如果用户没有特别指定其他格式要求**，请使用以下简化的两部分结构:
             * **主要发现**: 用简洁明了的语言概括核心发现和最重要的数据洞察，包括关键指标、主要趋势和异常点
             * **详细解读及建议**: 深入分析数据中的模式、原因和影响，并提供基于数据的建议和行动方向
           - 每个部分使用二级标题(##)标记
           - 适当使用Markdown列表、重点标记和简单表格提高可读性
        
        3. **内容质量要求**:
           - **主要发现部分**: 应当简洁精炼，控制在3-5个要点，每个要点1-2句话，总计不超过100字
           - **详细解读及建议部分**: 应当深入、具体，说明数据背后的原因、影响和可能的行动建议，字数控制在50到200字以内,不要为了凑字数而写，要根据数据量大小，合理控制字数
           - 使用精确的数值和百分比支持你的观点
           - 基于实际数据进行分析，避免空泛的概括
        
        4. **专业性与可读性平衡**:
           - 使用适当的数据分析术语，但确保非专业人士也能理解
           - 避免过于技术性的描述，注重商业洞察
           - 分段清晰，逻辑连贯
           - 使用简洁明了的语言，避免冗长复杂的句式
        
        ## 风格指南
        - 使用专业、客观的语气
        - 避免过度使用形容词和副词
        - 使用精确的数字而非模糊表述
        - 保持分析的逻辑性和连贯性
        - 全文必须使用Markdown格式
        
        请根据以上要求，生成针对"{dimension_name}"维度的专业数据解读，输出格式必须为Markdown。
        """

    @staticmethod
    def build_analysis_outline_prompt(data_structure: str, user_requirements: str, dataset_context: str = "") -> str:
        """
        构建分析大纲提示词
        
        参数:
            data_structure (str): 数据结构信息
            user_requirements (str): 用户需求
            dataset_context (str, optional): 数据集上下文信息，默认为空
            
        返回:
            str: 提示词字符串
        """
        # 解析dataset_context来获取现有维度的数量
        existing_dimensions_count = 0
        existing_dimensions_details = ""
        if dataset_context:
            try:
                context_data = json.loads(dataset_context)
                if "existing_dimensions" in context_data:
                    existing_dimensions = context_data["existing_dimensions"]
                    existing_dimensions_count = len(existing_dimensions)
                    
                    # 为提示添加现有维度的详细信息
                    if existing_dimensions_count > 0:
                        existing_dimensions_details = "\n\n## 现有分析维度信息\n"
                        for i, dim in enumerate(existing_dimensions):
                            dim_name = dim.get("分析维度(子节标题)", "")
                            dim_desc = dim.get("分析说明", "")
                            existing_dimensions_details += f"{i+1}. **{dim_name}**: {dim_desc}\n"
            except json.JSONDecodeError:
                # 如果解析失败，假设没有现有维度
                logger.error("无法解析dataset_context JSON")
        
        # 计算可以新生成的最大子节点数量
        max_new_sections = 8 - existing_dimensions_count
        max_new_sections = max(1, max_new_sections)  # 确保至少生成1个子节
        
        return f"""
        # 角色定位
        你是一位具有丰富行业经验的高级商业分析师，擅长将数据转化为有价值的商业洞察。你的任务是基于数据结构和用户需求，创建一份以客户为中心的分析大纲，既能指导后续SQL查询生成，又能为最终的客户报告提供清晰结构。

        # 输入信息
        ## 数据结构信息
        ```
        {data_structure}
        ```

        ## 用户分析需求
        ```
        {user_requirements}
        ```
        {existing_dimensions_details}
        # 数量限制
        - 系统已有 {existing_dimensions_count} 个分析维度
        - 你最多只能生成 {max_new_sections} 个新的分析子节点
        - 分析子节点的总数（现有 + 新生成）必须不超过 8 个
        - 确保生成的每个子节点都具有独特的分析价值和业务意义

        # 行业分析框架指南
        1. **描述分析层（必需）**
           - 核心业务指标的分布和趋势
           - 关键维度的占比和构成
           - 时间序列分析和周期性模式
        
        2. **诊断分析层（推荐）**
           - 业务指标的关联性分析
           - 异常值和波动原因分析
           - 细分维度的比较分析
        
        3. **预测分析层（可选）**
           - 趋势预测和未来展望
           - 假设情景分析
           - 潜在机会和风险评估

        # 数据结构解析指南
        1. **业务维度识别**
           - 识别可作为分析维度的字段（如时间、地区、产品类别、客户类型）
           - 理解维度间的层级关系（如年-季-月-日）
           - 关注具有业务意义的分类字段

        2. **指标字段识别**
           - 找出可量化的业务指标（如销售额、利润、数量、转化率）
           - 区分绝对指标和相对指标
           - 识别可计算的派生指标（如同比、环比、占比）

        3. **数据约束识别**
           - 了解数据的时间范围和颗粒度
           - 识别缺失值和可能的数据偏差
           - 考虑数据量大小对分析粒度的影响

        # 分析大纲生成指南
        1. **以业务问题为导向**
           - 每个分析章节应解答具体的业务问题
           - 从客户视角出发，关注决策价值
           - 优先考虑用户明确提出的分析需求

        2. **结构清晰且逻辑递进**
           - 从基础描述到深入洞察
           - 从整体到局部，从宏观到微观
           - 确保章节之间有明确的逻辑关联
           - 子节标题必须与表中数据相关，确保可基于现有数据进行分析
           - 分析说明必须详细且明确，以便后续能够根据描述生成相应的SQL查询

        3. **兼顾广度与深度**
           - 选择最有价值的分析角度，不要追求数量
           - 对重点问题进行深入分析
           - 适当包含探索性分析，发现潜在价值

        4. **注重实用性与可操作性**
           - 每个分析点都应该指向可能的行动建议
           - 关注具有决策参考价值的分析
           - 确保分析结果易于理解和应用

        5. **避免重复现有分析维度**
           - 检查现有分析维度信息，不要创建相似或重复的分析维度
           - 提供新颖的分析角度，与现有维度形成互补
           - 如果现有分析维度已经覆盖了某个关键指标，考虑从不同角度分析该指标

        # 输出格式要求
        请生成一份严格遵循以下JSON结构的分析大纲，不要包含SQL查询：

        ```json
        {{
          "分析标题": "数据分析报告：[针对业务主题的专业标题]",
          "大纲概述": "[3-4句话概述此分析报告的业务价值、主要内容和预期洞察]",
          "核心分析章节": [
            {{
              "章节标题": "[核心分析主题]",
              "子节": [
                {{
                  "子节标题": "[具体分析维度]",
                  "分析说明": "[具体业务指标]的[具体分析方向]"
                }}
              ]
            }}
          ]
        }}
        ```

        # 特别注意事项
        - 严格遵循上述JSON结构，确保JSON格式完全正确，可被直接解析
        - 分析说明要简明扼要，不超过20字，要具有指导性，帮助后续生成SQL
        - 所有章节中的子节点总数不得超过 {max_new_sections} 个，确保与现有维度加起来不超过8个
        - 仔细研读数据结构信息，确保理解所有表名、字段名及其数据类型
        - 不要在JSON中包含SQL查询，那将在后续步骤中单独生成
        - 每个章节和子节都应有唯一的ID，便于后续引用
        - 章节ID应为数字，子节ID为章节ID后跟序号
        - 不要包含"数据概览"章节，因为数据概览信息会通过其他方法直接获取
        - 只需专注于实质性的业务分析章节和子节
        - 分析说明要简明扼要，不超过20字，要同时具有业务导向性和技术指导性
        - 所有章节标题和分析说明都应使用专业的商业分析语言，避免技术性词汇
        - 确保大纲完全覆盖用户的所有分析需求
        - 分析章节应具有明确的业务价值导向，从描述性分析到诊断性和预测性分析
        - 始终保持客户视角，关注能够支持业务决策的分析
        - JSON中所有键名必须使用中文，与示例一致
        - 输出必须是严格遵循模式的有效JSON，不包含任何额外注释或说明文字

        # 常见业务分析场景参考
        1. **销售分析**
           - 销售趋势与周期性
           - 产品/服务组合分析
           - 客户细分与价值分析
           - 销售渠道效率分析
           
        2. **市场分析**
           - 市场占有率分析
           - 竞争对手比较
           - 营销活动效果分析
           - 客户行为与偏好分析
           
        3. **运营分析**
           - 流程效率与瓶颈分析
           - 资源利用率分析
           - 质量与合规分析
           - 成本结构分析
           
        4. **财务分析**
           - 盈利能力与成本分析
           - 现金流与资金周转分析
           - 投资回报率分析
           - 预算执行情况分析
        """
    @staticmethod
    def build_report_to_html_prompt(report_md: str, user_requirements: str = "", additional_context: str = "") -> str:
        """
        构建用于将Markdown格式的分析报告转换为精美HTML页面的提示词
        
        参数:
            report_md (str): Markdown格式的分析报告内容
            user_requirements (str, optional): 用户对报告生成的特定要求，如样式、图表类型、交互性等
            additional_context (str, optional): 额外的上下文信息或要求，默认为空
            
        返回:
            str: 提示词字符串
        """
        # 处理用户要求
        user_requirements_section = ""
        if user_requirements and user_requirements.strip():
            user_requirements_section = f"""
        ## 用户特定要求
        以下是用户对报告生成的特定要求，请优先考虑实现这些要求：
        ```
        {user_requirements}
        ```
        
        注意：用户的特定要求优先级高于下面的默认技术和设计要求。如果用户要求与默认要求冲突，应以用户要求为准。
        """

        return f"""
        # 任务：将Markdown格式的数据分析报告转换为专业优美的HTML页面（支持PDF导出）

        ## 输入报告内容
        ```markdown
        {report_md}
        ```
        {user_requirements_section}
        ## 额外上下文信息
        {additional_context}

        ## 任务目标
        你是一位专业的数据可视化和报告设计专家，需要将提供的Markdown格式分析报告转换为一个美观、专业的HTML页面，并将适合图表化展示的数据使用Chart.js实现可视化。生成的页面应具有专业的设计风格，同时兼容PDF导出需求。

        ## 技术要求
        1. **基本HTML结构**
           - 使用HTML5标准
           - 包含完整的<!DOCTYPE>、<html>、<head>和<body>标签
           - 添加适当的meta标签确保响应式设计和搜索引擎优化
           - 使用UTF-8字符编码
           - 添加适当的viewport设置，确保在不同设备上正确显示

        2. **CSS样式**
           - 创建专业、现代的设计风格
           - 使用CSS变量定义主题色
           - 设计响应式布局，适应不同屏幕尺寸
           - 使用适当的字体、间距和颜色方案提高可读性
           - 设计美观的标题、段落、列表和表格样式
           - 使用@media print媒体查询优化PDF导出时的样式
           - 避免使用可能在PDF转换中丢失的CSS功能（如某些动画、阴影效果）

        3. **Chart.js集成**
           - 引入Chart.js库（使用CDN: https://cdn.jsdelivr.net/npm/chart.js）
           - 将报告中的表格数据转换为适当的图表类型
           - 为每个图表创建canvas元素并分配唯一ID
           - 编写JavaScript代码初始化和配置图表
           - 确保图表有合适的标题、图例和标签
           - 添加图表导出功能，允许单独保存图表为图片

        4. **图表类型选择指南**
           - 时间序列数据：使用折线图或面积图
           - 分类比较数据：使用柱状图或条形图
           - 部分与整体关系：使用饼图或环形图
           - 分布数据：使用散点图或直方图
           - 复杂的多维数据：使用雷达图或混合图表
           - 考虑数据量和复杂度，选择最能清晰表达见解的图表类型

        5. **交互性与兼容性**
           - 为图表添加悬停提示
           - 为长篇报告添加目录导航（支持锚点）
           - 添加打印友好按钮，自动应用打印优化样式
           - 确保在PDF导出时图表能被正确渲染
           - 添加导出为PDF的按钮（使用浏览器原生打印功能）
           - 实现图表和表格视图的切换功能

        ## 数据处理原则
        1. **表格识别**
           - 识别Markdown中的表格
           - 分析表格内容，判断是否适合转换为图表
           - 考虑数据类型、行数、列关系等因素
           - 对复杂表格，保留原表格并添加图表辅助理解

        2. **图表化决策**
           - 数值型比较（2-8个类别）：优先使用柱状图或条形图
           - 时间趋势数据：优先使用折线图
           - 比例关系（2-6个类别）：优先使用饼图或环形图
           - 双变量关系：优先使用散点图
           - 如表格行数>20，考虑使用可滚动表格而非全部转为图表
           - 确保每个图表都有明确的业务见解或结论

        3. **数据准备**
           - 提取表格标题作为图表标题
           - 提取表头作为图表标签
           - 提取数据值并转换为适当的数据结构
           - 适当处理百分比、货币等特殊格式
           - 对异常值进行适当标注
           - 确保图表使用适当的颜色区分不同数据系列

        ## 设计风格指南
        1. **整体布局**
           - 使用企业级专业设计风格
           - 添加公司logo占位区域（顶部居左）
           - 为报告添加封面页，包含报告标题、生成日期、标志性图表
           - 添加页眉和页脚，支持PDF页码
           - 正文采用一致的分栏布局，提高可读性
           - 合理使用留白和分隔线增强结构感
           - 确保内容区域宽度适中，避免过长行影响阅读

        2. **配色方案**
           - 使用专业的数据可视化配色
           - 主色调：#1a73e8（专业蓝色）
           - 辅助色：#34a853（绿色）、#ea4335（红色）、#fbbc04（黄色）、#4285f4（亮蓝色）
           - 背景色：#ffffff（白色）与#f8f9fa（浅灰）组合
           - 文字色：#202124（深灰，主文本）、#5f6368（中灰，次要文本）
           - 强调色：#1967d2（深蓝，用于链接和重点）
           - 确保足够的颜色对比度，提高可访问性和打印质量

        3. **图表样式**
           - 统一的图表风格，确保整体视觉一致性
           - 使用专业配色方案，避免过于鲜艳的色彩
           - 适当的图表大小（根据数据复杂度调整）
           - 清晰的标签和图例，避免过度装饰
           - 添加数据来源和注释说明
           - 确保图表在打印时保持清晰度
           - 为每个图表添加简短的见解说明

        4. **排版规范**
           - 使用sans-serif字体系列（如Roboto、Arial、Helvetica）
           - 标题使用层次清晰的大小和粗细
           - 正文字体大小适中（16px），行高1.5-1.6
           - 图表标题统一样式，简洁明了
           - 重要数据或结论使用醒目但不夸张的强调样式
           - 确保字体在PDF导出时不失真

        ## PDF导出兼容性
        1. **页面设置**
           - 添加@page CSS规则，设置合适的页面大小（如A4）
           - 设置适当的页边距
           - 避免内容被页面边缘截断
           - 实现分页控制，避免图表或表格被拆分到不同页面
           - 为不同部分设置page-break-before/after属性

        2. **打印优化**
           - 使用@media print查询设置打印特定样式
           - 隐藏打印时不需要的元素（如导航按钮）
           - 优化背景色和图片，减少打印墨水消耗
           - 确保文字在打印时足够清晰
           - 添加页眉页脚支持页码显示

        3. **图表处理**
           - 确保图表在打印前完全渲染
           - 为图表添加高分辨率导出选项
           - 调整图表大小和比例，适合常见纸张大小
           - 优化图表颜色，确保在黑白打印时仍可识别

        ## 专业性增强
        1. **报告结构**
           - 添加专业的封面页（含标题、日期、公司信息占位）
           - 自动生成内容目录，带页码和链接
           - 添加执行摘要部分，总结关键发现
           - 正文保持一致的章节结构
           - 末尾添加结论和建议部分
           - 必要时提供附录和参考资料部分

        2. **专业元素**
           - 为重要见解添加醒目的"关键发现"标记
           - 使用专业的数据标注和引用格式
           - 添加数据来源和方法说明
           - 包含适当的免责声明和版权信息
           - 使用专业术语和表达方式
           - 添加页码和章节编号

        ## 输出格式
        提供完整的HTML代码，包括内联的CSS和JavaScript。代码应当包含以下几个主要部分：
        1. HTML结构（包含完整的文档结构，支持PDF导出）
        2. CSS样式（内联在<style>标签中，包含@media print规则）
        3. 图表初始化代码（放在<script>标签中）
        4. 导出和交互功能（包括PDF导出支持）

        ## 代码质量要求
        1. 代码应当简洁、高效、易读
        2. 适当添加注释解释复杂逻辑
        3. 确保HTML、CSS和JavaScript代码无语法错误
        4. 使用语义化HTML元素增强可访问性和SEO
        5. 优先使用CSS Grid或Flexbox实现布局
        6. 确保JavaScript代码在打印前执行完成
        7. 添加适当的错误处理机制

        ## 最终输出
        请输出完整的、可直接使用的HTML代码。代码应当自包含所有需要的CSS和JavaScript，并具有良好的PDF导出兼容性。
        
        输出格式：
        ```html
        <!-- 在此处放置完整的HTML代码 -->
        ```
        """

    @staticmethod
    def build_html_template_prompt(user_requirements: str = "", additional_context: str = "") -> str:
        """
        构建用于生成HTML报告模板的提示词，而不是处理完整报告内容
        
        参数:
            user_requirements (str, optional): 用户对报告生成的特定要求，如样式、图表类型、交互性等
            additional_context (str, optional): 额外的上下文信息或要求，默认为空
            
        返回:
            str: 提示词字符串
        """
        # 处理用户要求
        user_requirements_section = ""
        if user_requirements and user_requirements.strip():
            user_requirements_section = f"""
        ## 用户特定要求
        以下是用户对报告生成的特定要求，请优先考虑实现这些要求：
        ```
        {user_requirements}
        ```
        
        注意：用户的特定要求优先级高于下面的默认技术和设计要求。如果用户要求与默认要求冲突，应以用户要求为准。
        """

        return f"""
        # 任务：生成数据分析报告的HTML模板

        {user_requirements_section}
        ## 额外上下文信息
        {additional_context}

        ## 任务目标
        你是一位专业的数据可视化和报告设计专家，需要创建一个HTML模板，用于展示数据分析报告。我们将在后续使用代码将Markdown内容填充到这个模板中，而不是让你直接处理完整的报告内容。

        ## 技术要求
        1. **基本HTML结构**
           - 使用HTML5标准
           - 包含完整的<!DOCTYPE>、<html>、<head>和<body>标签
           - 添加适当的meta标签确保响应式设计和搜索引擎优化
           - 使用UTF-8字符编码
           - 添加适当的viewport设置，确保在不同设备上正确显示

        2. **CSS样式**
           - 创建专业、现代的设计风格
           - 使用CSS变量定义主题色
           - 设计响应式布局，适应不同屏幕尺寸
           - 使用适当的字体、间距和颜色方案提高可读性
           - 设计美观的标题、段落、列表和表格样式
           - 使用@media print媒体查询优化PDF导出时的样式

        3. **Chart.js集成**
           - 引入Chart.js库（使用CDN: https://cdn.jsdelivr.net/npm/chart.js）
           - 提供图表渲染的公共函数和辅助方法
           - 设计一致的图表样式

        4. **模板结构**
           - 提供一个包含以下元素的HTML框架:
             * 报告标题区域 (带id="report-title")
             * 报告描述/摘要区域 (带id="report-description")
             * 目录区域 (带id="table-of-contents")
             * 正文内容区域 (带id="report-content")，此区域将通过JavaScript动态填充内容
           - 提供导航栏
           - 设计页眉和页脚

        5. **JavaScript辅助函数**
           - 提供解析和渲染Markdown的函数 (可以使用marked.js库)
           - 提供解析表格数据并生成图表的函数
           - 提供目录生成和导航函数
           - 提供PDF导出功能

        ## 设计风格指南
        1. **整体布局**
           - 使用企业级专业设计风格
           - 添加公司logo占位区域（顶部居左）
           - 页面应包含封面设计
           - 添加页眉和页脚，支持PDF页码
           - 正文采用一致的分栏布局，提高可读性

        2. **配色方案**
           - 使用专业的数据可视化配色
           - 主色调：#1a73e8（专业蓝色）
           - 辅助色：#34a853（绿色）、#ea4335（红色）、#fbbc04（黄色）、#4285f4（亮蓝色）
           - 背景色：#ffffff（白色）与#f8f9fa（浅灰）组合
           - 文字色：#202124（深灰，主文本）、#5f6368（中灰，次要文本）
           - 强调色：#1967d2（深蓝，用于链接和重点）

        3. **图表样式**
           - 统一的图表风格，确保整体视觉一致性
           - 使用专业配色方案，避免过于鲜艳的色彩
           - 为图表提供默认的尺寸和样式设置

        4. **排版规范**
           - 使用sans-serif字体系列（如Roboto、Arial、Helvetica）
           - 标题使用层次清晰的大小和粗细
           - 正文字体大小适中（16px），行高1.5-1.6

        ## PDF导出兼容性
        1. **页面设置**
           - 添加@page CSS规则，设置合适的页面大小（如A4）
           - 设置适当的页边距
           - 实现分页控制，避免图表或表格被拆分到不同页面

        2. **打印优化**
           - 使用@media print查询设置打印特定样式
           - 隐藏打印时不需要的元素（如导航按钮）
           - 优化背景色和图片，减少打印墨水消耗

        ## JavaScript功能需求
        提供以下JavaScript函数:
        1. **renderMarkdown(elementId, markdownContent)**: 将Markdown内容渲染到指定元素
        2. **renderChart(canvasId, tableData, chartType)**: 根据表格数据渲染图表
        3. **generateTableOfContents()**: 自动生成目录
        4. **exportToPdf()**: 导出为PDF文件

        ## 关于动态内容填充
        模板应当假设以下内容将通过JavaScript动态填充:
        - 报告标题和描述
        - Markdown格式的章节内容
        - 表格数据（将被Chart.js转换为图表）

        ## 代码质量要求
        1. 代码应当简洁、高效、易读
        2. 适当添加注释解释复杂逻辑
        3. 确保HTML、CSS和JavaScript代码无语法错误
        4. 使用语义化HTML元素增强可访问性和SEO

        ## 最终输出
        请输出完整的、可直接使用的HTML模板代码。代码应当自包含所有需要的CSS，并引用必要的外部库（如Chart.js和marked.js）。
        
        输出格式：
        ```html
        <!-- 在此处放置完整的HTML模板代码 -->
        ```
        """
